Schrift
Wiki:Tipp zum Debugging: use Data::Dumper; local $Data::Dumper::Useqq = 1; print Dumper \@var;
[thread]11756[/thread]

Zugriff auf Membervariable aus Instanzmethode?



<< |< 1 2 >| >> 17 Einträge, 2 Seiten
JackBauer
 2008-05-06 12:13
#109234 #109234
User since
2008-04-30
16 Artikel
BenutzerIn
[default_avatar]
Hi zusammen!

Meine Klasse ist wie folgt definiert:

Code: (dl )
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
sub new 
{
my $class = shift;
my $self = {};
$self->{filename} = undef;
$self->{path} = undef;
$self->{logRespository} = undef;
$self->{mcg} = undef;
$self->{reader} = undef;
$self->{timeStamp} = undef;

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

...

sub reader
{
my $self=shift;
if (@_) { $self->{reader} = shift }
return $self->{reader};
}

...

sub run
{
my $self=shift;

my $count = getIMSIcount();

#sleep(1000);

#workaround: disable BTS AXC and BTS WAM network interface
logprint("Disabling BTS AXC & WAM interface ...\n");
system("C:\\BFAT\\bfat_tools\\DevCon\\devcon disable PCI\\VEN_11AB");
system("C:\\BFAT\\bfat_tools\\DevCon\\devcon disable PCI\\VEN_13F0");
sleep(8);

StartMcgTestcase('mcg' => $self->{mcg}, 'reader' => $self->{reader}, 'tcName' => $self->{filename}, 'timestamp' => $self->{timeStamp});

# wait 30 seconds for each IMSI of the testcase

for(my $i = 0; $i <= $count; $i++)
{
sleep(30);
}

#workaround: enable BTS AXC and BTS WAM network interface again
logprint("Enabling BTS AXC & WAM interface ...\n");
system("C:\\BFAT\\bfat_tools\\DevCon\\devcon enable PCI\\VEN_11AB");
system("C:\\BFAT\\bfat_tools\\DevCon\\devcon enable PCI\\VEN_13F0");

StopMcgTestcaseAndTransferMcgLogs('mcg' => $self->{mcg}, 'reader' => $self->{reader}, 'repository' => $self->{logRespository});
}

...

sub getIMSIcount
{
$self=shift;

my $mcg_tc_log_base_dir = $self->{reader}->getTestCaseParam("mcg_tc_log_dir");
print $mcg_tc_log_base_dir."\n";

sleep(1000);
}



Von dieser Klasse bilde ich in einer anderen Datei eine Instanz und rufe schließlich die Methode run() auf. Da dies auf Instanzebene läuft, bin ich dazu in der Lage mittels der Variable $self auf meine Membervariable $reader zuzugreifen.

Innerhalb der run-Methode möchte ich nun die getIMSIcount-Methode aufrufen, die ebenfalls Zugriff auf reader hat.

In Java würde ich dieses Problem recht leicht mit this lösen. Wie stelle ich es am besten in Perl an ohne an die 2. Methode $self mitzuübergeben?

Gruß JackBauer
renee
 2008-05-06 12:19
#109236 #109236
User since
2003-08-04
14371 Artikel
ModeratorIn
[Homepage] [default_avatar]
Genau wie in Java arbeitest Du mit dem Objekt:

Code (perl): (dl )
1
2
3
4
5
sub run
{    
    my $self=shift;

    my $count = $self->getIMSIcount();


Wobei das dann automatisch das Objekt als ersten Parameter übergibt...
OTRS-Erweiterungen (http://feature-addons.de/)
Frankfurt Perlmongers (http://frankfurt.pm/)
--

Unterlagen OTRS-Workshop 2012: http://otrs.perl-services.de/workshop.html
Perl-Entwicklung: http://perl-services.de/
renee
 2008-05-06 12:22
#109237 #109237
User since
2003-08-04
14371 Artikel
ModeratorIn
[Homepage] [default_avatar]
Übrigens solltest Du die getter/setter-Methoden auch nutzen wenn Du sie schon hast ;-)

Aus
Code (perl): (dl )
my $mcg_tc_log_base_dir = $self->{reader}->getTestCaseParam("mcg_tc_log_dir");
ein
Code (perl): (dl )
my $mcg_tc_log_base_dir = $self->reader->getTestCaseParam("mcg_tc_log_dir");


und aus
Code (perl): (dl )
$self->{reader}            = undef;
ein
Code (perl): (dl )
$self->reader(undef);


Ist weniger Tipparbeit, ist übersichtlicher und ermöglicht es Dir, leichter mal Änderungen an der Struktur des Objekts vorzunehmen, ohne dass Du den gesamten Code anfassen musst.
OTRS-Erweiterungen (http://feature-addons.de/)
Frankfurt Perlmongers (http://frankfurt.pm/)
--

Unterlagen OTRS-Workshop 2012: http://otrs.perl-services.de/workshop.html
Perl-Entwicklung: http://perl-services.de/
JackBauer
 2008-05-06 12:26
#109238 #109238
User since
2008-04-30
16 Artikel
BenutzerIn
[default_avatar]
Danke für die Antwort :-)

Zu den Gettern/Settern:

Was ist denn inhaltlich der Unterschied zwischen $self->{reader} und $self->reader - sprich: was haben die geschweiften Klammern für eine Funktion?
sid burn
 2008-05-06 12:30
#109239 #109239
User since
2006-03-29
1520 Artikel
BenutzerIn

user image
JackBauer+2008-05-06 10:26:37--
Zu den Gettern/Settern:

Was ist denn inhaltlich der Unterschied zwischen $self->{reader} und $self->reader - sprich: was haben die geschweiften Klammern für eine Funktion?

hmm, das solltest du aber eigentlich Wissen...

Mit den Pfeil derefernzierst du. Und mit den geschweiften Klammern greifst du sofort auf den hash zu. Sprich auf die interna des Objektes. Und mit $self->reader rufst du eine Methode vom Objekt auf.

Ein zusätzlicher Punkt den renee nicht sagte was noch ein Vorteil bei Methodenzugriff ist. Du bekommst eine Fehlermeldung wenn du dich vertippst. Bei einem hash wird dann stillschweigend einfach ein neuer key angelegt.
Nicht mehr aktiv. Bei Kontakt: ICQ: 404181669 E-Mail: perl@david-raab.de
nepos
 2008-05-06 12:33
#109240 #109240
User since
2005-08-17
1420 Artikel
BenutzerIn
[Homepage] [default_avatar]
$self ist im Prinzip nur eine Hash-Referenz (meistens jedenfalls). Das heisst, die {} sind, wie bei Hashes üblich einfach für den Zugriff auf einen Hashkey zuständig.

Der Unterschied zwischen $self->{reader} und $self->reader() ist einfach der, dass du im ersten Fall direkt im Hash und damit in deinem Objekt rummachst, im zweiten Fall dazu ein Funktion nutzt, in der du falsche Parameter abfangen kannst oder einiges mehr machen kannst.
Insbesondere verbirgst du mittels der Methode reader() den internen Aufbaue deines Objekts. Der hat denjenigen, der damit arbeitet auch nicht zu interessieren. Der soll das Interface, sprich die Methoden nutzen. Und du kannst dadurch einfach die Internas bei Bedarf verändern. Da alle das Interface benutzen merken die davon nix. Im ersten Fall, wo du direkt auf Internas zugreifst muss dann sehr viel Code angepasst werden.
JackBauer
 2008-05-06 12:46
#109241 #109241
User since
2008-04-30
16 Artikel
BenutzerIn
[default_avatar]
Alles klar - wieder was dazu gelernt :-)

Bin halt noch recht neu in der Perl Welt und bin dabei mir meine Analogien zu C++ oder Java zu suchen.

Momentan weiß ich noch nicht so recht, was ich von Perl halten soll. Ich sehe jedenfalls absolut keinen Sinn darin Methoden kurz aber kryptisch zu designen, sodass anschließend bei schlechter Dokumentation keiner mehr weiß, was überhaupt gemacht wurde:

Bsp:

Paramter einer Methode stehen automatisch in $_

Die letzte Zeile einer Methode setzt einen versteckten Rückgabewert (bin mir nicht sicher: auch in $_ ?), auf den man dann an anderer Stelle wieder zugreifen kann.
renee
 2008-05-06 12:53
#109242 #109242
User since
2003-08-04
14371 Artikel
ModeratorIn
[Homepage] [default_avatar]
JackBauer+2008-05-06 10:46:02--
Momentan weiß ich noch nicht so recht, was ich von Perl halten soll. Ich sehe jedenfalls absolut keinen Sinn darin Methoden kurz aber kryptisch zu designen, sodass anschließend bei schlechter Dokumentation keiner mehr weiß, was überhaupt gemacht wurde

Das verstehe ich nicht so ganz. Was meinst Du damit?

Wenn Du Perls built-in-Methode meinst, die sind recht ausführlich dokumentiert (Stichwort "perldoc -f <funktion>")

Wie Du Deine eigenen Methoden schreibst, ist Dir selbst überlassen.

Quote
Paramter einer Methode stehen automatisch in $_


Die stehen nicht in $_ sondern in @_. Und es ist eine Sache der Gewohnheit... Man hat sich nach 1,2 Tagen daran gewöhnt, dass die Parameter in @_ stehen...

Quote
Die letzte Zeile einer Methode setzt einen versteckten Rückgabewert (bin mir nicht sicher: auch in $_ ?)
Nein, nicht in $_... Du muss den Rückgabewert schon explizit speichern:

Code (perl): (dl )
1
2
3
4
5
6
my $retval = test();
print $retval;

sub test{
  6;
}


Es gibt sicherlich das eine oder andere was in Perl nicht 100%ig optimal ist, aber in welcher Sprache ist schon alles optimal?
OTRS-Erweiterungen (http://feature-addons.de/)
Frankfurt Perlmongers (http://frankfurt.pm/)
--

Unterlagen OTRS-Workshop 2012: http://otrs.perl-services.de/workshop.html
Perl-Entwicklung: http://perl-services.de/
JackBauer
 2008-05-06 13:10
#109245 #109245
User since
2008-04-30
16 Artikel
BenutzerIn
[default_avatar]
Ich meinte halt einfach, dass man in Perl recht viele Dinge vor den Benutzer verstecken kann. Vielleicht bin ich es als Java-Programmierer anders gewöhnt, aber

Code: (dl )
1
2
3
4
5
6
int getSum(int a, int b)
{
return a + b;
}

int x = getSum(2, 3);


ist für mich übersichtlicher als

Code: (dl )
1
2
3
4
5
6
sub getSum()
{
$_[0] + $_[1];
}

$x = getSum(2, 3);


Für jemand, der schon lange mit Perl zu tun hatte, mag das vielleicht anders aussehen, aber mich stört es, wenn man den Rückgabewert nicht explizit mit return angibt. (siehe dein zweites Beispiel: 6; )

Vielleicht verstehst du ja jetzt worauf ich hinaus möchte?
nepos
 2008-05-06 13:10
#109246 #109246
User since
2005-08-17
1420 Artikel
BenutzerIn
[Homepage] [default_avatar]
Man muss diese "Magie" aber auch nicht unbedingt nutzen.
Wobei es an manchen Stellen sinnvoll sein kann, da z.B. direktes benutzen von $_ schneller ist, als eine extra Variable dafür anzulegen.
<< |< 1 2 >| >> 17 Einträge, 2 Seiten



View all threads created 2008-05-06 12:13.