Komplexe Datenstrukturen vereinfachen

Hallo,

in einem Programm versuche ich mich in der OO-Programmierung - das erste
mal überhaupt :-)
Dabei habe ich unter anderem folgende Datenstuktur:
$$r_Programm{PUNKTELISTE}[1]{JOINT_SPEED}

Nun habe ich mir gedacht, ich vereinfache das ganze wie folgt
my $attribut = $$r_Programm{PUNKTELISTE}[1];
so daß ich mit $attribut{JOINT_SPEED} auf den Hash zugreifen kann.
Nur warum hat Perl etwas gegen diese Vorgehensweise?

Ich meine mich erinnern zu können, daß das in der Art möglich ist. Nur
das ist halt schon wieder Monate her, wo ich das gelesen habe.

Gruß Markus.

Re: Komplexe Datenstrukturen vereinfachen

Markus Hochholzer wrote:

> in einem Programm versuche ich mich in der OO-Programmierung - das erste
> mal überhaupt :-)
> Dabei habe ich unter anderem folgende Datenstuktur:
> $$r_Programm{PUNKTELISTE}[1]{JOINT_SPEED}
>
> Nun habe ich mir gedacht, ich vereinfache das ganze wie folgt
> my $attribut = $$r_Programm{PUNKTELISTE}[1];
> so daß ich mit $attribut{JOINT_SPEED} auf den Hash zugreifen kann.
> Nur warum hat Perl etwas gegen diese Vorgehensweise?

Es muss lauten: $attribut->{JOINT_SPEED}
BTW: Deine Datenstruktur hat nichts mit OO zu tun.

Grüße
Frank
--
Dipl.-Inform. Frank Seitz; http://www.fseitz.de/
Anwendungen für Ihr Internet und Intranet
Tel: 04103/180301; Fax: -02; Industriestr. 31, 22880 Wedel

Re: Komplexe Datenstrukturen vereinfachen

Frank Seitz schrieb:

>
> Es muss lauten: $attribut->{JOINT_SPEED}

Danke!

> BTW: Deine Datenstruktur hat nichts mit OO zu tun.

Warum? Woran machst Du das fest?
Wie gesagt, ich bin nur Hobbyprogrammierer (ca. 14Tage im Jahr). KW03
und KW04 werden es wohl in 2007 sein - leider.

Gruß Markus

Re: Komplexe Datenstrukturen vereinfachen

Markus Hochholzer wrote:
> Frank Seitz schrieb:
>>
>>BTW: Deine Datenstruktur hat nichts mit OO zu tun.
>
> Warum? Woran machst Du das fest?

Zu einem OO-Ansatz wird es erst, wenn Du die Datenstruktur
durch eine oder mehrere Klassen kapselst.

> Wie gesagt, ich bin nur Hobbyprogrammierer (ca. 14Tage im Jahr). KW03
> und KW04 werden es wohl in 2007 sein - leider.

Dann ist meine Bemerkung nicht unbedingt wichtig für Dich.

Grüße
Frank
--
Dipl.-Inform. Frank Seitz; http://www.fseitz.de/
Anwendungen für Ihr Internet und Intranet
Tel: 04103/180301; Fax: -02; Industriestr. 31, 22880 Wedel

Re: Komplexe Datenstrukturen vereinfachen

Frank Seitz schrieb:
> Markus Hochholzer wrote:
>> Frank Seitz schrieb:
>>> BTW: Deine Datenstruktur hat nichts mit OO zu tun.
>> Warum? Woran machst Du das fest?
>
> Zu einem OO-Ansatz wird es erst, wenn Du die Datenstruktur
> durch eine oder mehrere Klassen kapselst.

Ich werde das beherzigen und deshalb das entsprechend nochmals nachlesen.

>> Wie gesagt, ich bin nur Hobbyprogrammierer (ca. 14Tage im Jahr). KW03
>> und KW04 werden es wohl in 2007 sein - leider.
>
> Dann ist meine Bemerkung nicht unbedingt wichtig für Dich.

Ganz im Gegenteil! Ich versuche auch besser zu werden und bin deshalb
für jeden Tipp dankbar.

Gruß Markus

Re: Komplexe Datenstrukturen vereinfachen

Am Fri, 19 Jan 2007 13:31:37 +0100 schrieb Markus Hochholzer:

> Hallo,
>
> in einem Programm versuche ich mich in der OO-Programmierung - das erste
> mal überhaupt :-)
> Dabei habe ich unter anderem folgende Datenstuktur:
> $$r_Programm{PUNKTELISTE}[1]{JOINT_SPEED}
>
> Nun habe ich mir gedacht, ich vereinfache das ganze wie folgt
> my $attribut = $$r_Programm{PUNKTELISTE}[1];
> so daß ich mit $attribut{JOINT_SPEED} auf den Hash zugreifen kann.
> Nur warum hat Perl etwas gegen diese Vorgehensweise?

$attribut ist kein Hash sondern eine Referenz auf einen Hash, wenn du den
Hash selbst willst:

%attribut = %{ $$r_Programm{PUNKTELISTE}[1] };

dann funktioniert auch $attribut{JOINT_SPEED}

wenn du die Referenz verwendest, wie schon gesagt mit dem arrow-operator
dereferenzieren: $attribut->{JOINT_SPEED}

für bessere Lesbarkeit:

$$r_Programm{PUNKTELISTE}[1]{JOINT_SPEED}

entspricht

${ $r_Programm{PUNKTELISTE}[1] }{JOINT_SPEED}

Wenn solche verschachtelten und referenzierten Datenstrukturen häufig
vorkommen, ist das entweder ein Zeichen für schlechtes Design oder für
Faulheit. Hash-Keys in Großschreibung sind auch nicht gut, weil man das
leicht mit Konstanten verwechseln kann. Das ist wichtig, weil Konstanten
sind unveränderlich und hash-keys führen in Perl ein munteres Eigenleben.

Schau unbedingt bei 'perldoc perlref' vorbei, weil ohne Verständnis
von Referenzen kannst Du in Perl nicht objektorientiert arbeiten...


Eine OO-Datenstruktur könnte ungefähr so aussehen:

package r_Programm;
{
# Konstruktor
sub new {
my $class = shift;
my $self = bless {}, $class;

$self->{_punkteliste} = [];
$self->{_attributes} = {}; # für joint_speed usw...


return $self;
}

# Klassenmethoden

# ...

sub get_punkteliste {
my ($self, $index) = @_;

return $self->{_punkteliste}->[$index];
}
}

Dann kannst Du ein Objekt (eine Referenz) erzeugen:

my $obj = r_Programm->new;

my %attribut = %{ $obj->get_punkteliste(1) };

print $attribut{joint_speed};

Re: Komplexe Datenstrukturen vereinfachen

Philipp E. Letschert schrieb:
[...]
> Wenn solche verschachtelten und referenzierten Datenstrukturen häufig
> vorkommen, ist das entweder ein Zeichen für schlechtes Design oder für
> Faulheit.

Trifft beides sicherlich zu.

> Hash-Keys in GroÃ?schreibung sind auch nicht gut, weil man das
> leicht mit Konstanten verwechseln kann. Das ist wichtig, weil Konstanten
> sind unveränderlich und hash-keys führen in Perl ein munteres Eigenleben.
> Schau unbedingt bei 'perldoc perlref' vorbei, weil ohne Verständnis
> von Referenzen kannst Du in Perl nicht objektorientiert arbeiten...

Arbeite mit dem O'Reilly Buch "Fortgeschrittene Perl Programmierung",
aber aus Zeitgründen eben nicht so, wie man eigentlich sollte.

[...]

Re: Komplexe Datenstrukturen vereinfachen

On 2007-01-20 04:34, Philipp E. Letschert wrote:
> Am Fri, 19 Jan 2007 13:31:37 +0100 schrieb Markus Hochholzer:
>> $$r_Programm{PUNKTELISTE}[1]{JOINT_SPEED}
>
> $$r_Programm{PUNKTELISTE}[1]{JOINT_SPEED}
>
> entspricht
>
> ${ $r_Programm{PUNKTELISTE}[1] }{JOINT_SPEED}

Nein:

#!/usr/bin/perl
use warnings;
use strict;

my $r_Programm = {
PUNKTELISTE => [
undef,
{ JOINT_SPEED => 23, }
]
};

my %r_Programm = (
PUNKTELISTE => [
undef,
{ JOINT_SPEED => 42, }
]
);


print $$r_Programm{PUNKTELISTE}[1]{JOINT_SPEED}, "\n";
print ${ $r_Programm{PUNKTELISTE}[1] }{JOINT_SPEED}, "\n";

Ergibt:

23
42

die beiden sind also offensichtlich nicht äquivalent (wäre auch
unlogisch - warum sollte die indirekte Klammerung gerade 2 von 3
Indirektionen umfassen und nicht alle oder keine?).

print ${$r_Programm}{PUNKTELISTE}[1]{JOINT_SPEED}, "\n";
print $r_Programm->{PUNKTELISTE}[1]{JOINT_SPEED}, "\n";

ergeben beide 23, sind also äquivalent zur Form des OP. Ich halte die
letzte Form für die lesbarste.

hp

--
_ | Peter J. Holzer | > Wieso sollte man etwas erfinden was nicht
|_|_) | Sysadmin WSR | > ist?
| | | hjp@hjp.at | Was sonst wäre der Sinn des Erfindens?
__/ | http://www.hjp.at/ | -- P. Einstein u. V. Gringmuth in desd

Re: Komplexe Datenstrukturen vereinfachen

Markus Hochholzer wrote:
> Arbeite mit dem O'Reilly Buch "Fortgeschrittene Perl Programmierung",
> aber aus Zeitgründen eben nicht so, wie man eigentlich sollte.

Die Version 1 (Srinivasan)
(vgl.: http://www.oreilly.de/catalog/fortperlger/errata.html)

oder die Version 2 (Cozens)?

Viele Grüße

M.

Re: Komplexe Datenstrukturen vereinfachen

Mirco Wahab schrieb:
> Markus Hochholzer wrote:
>> Arbeite mit dem O'Reilly Buch "Fortgeschrittene Perl Programmierung",
>> aber aus Zeitgründen eben nicht so, wie man eigentlich sollte.
>
> Die Version 1 (Srinivasan)
> (vgl.: http://www.oreilly.de/catalog/fortperlger/errata.html)

Ist "offiziell" vergriffen, soweit ich weiss. Vielleicht aber noch in
Antiquariaten oder bei ebay zu haben.

> oder die Version 2 (Cozens)?

Gibt's leider nur auf englisch. Vielleicht kann ich den Verlag aber
überreden, mir da mal nen Job zu geben. :o)

Joergen

Re: Komplexe Datenstrukturen vereinfachen

Am Sat, 20 Jan 2007 11:42:04 +0100 schrieb Peter J. Holzer:

> On 2007-01-20 04:34, Philipp E. Letschert wrote:
>> Am Fri, 19 Jan 2007 13:31:37 +0100 schrieb Markus Hochholzer:
>>> $$r_Programm{PUNKTELISTE}[1]{JOINT_SPEED}
>>
>> $$r_Programm{PUNKTELISTE}[1]{JOINT_SPEED}
>>
>> entspricht
>>
>> ${ $r_Programm{PUNKTELISTE}[1] }{JOINT_SPEED}
>
> Nein:
>
> #!/usr/bin/perl
> use warnings;
> use strict;
>
> my $r_Programm = {
> PUNKTELISTE => [
> undef,
> { JOINT_SPEED => 23, }
> ]
> };
>
> my %r_Programm = (
> PUNKTELISTE => [
> undef,
> { JOINT_SPEED => 42, }
> ]
> );
>
>
> print $$r_Programm{PUNKTELISTE}[1]{JOINT_SPEED}, "\n";
> print ${ $r_Programm{PUNKTELISTE}[1] }{JOINT_SPEED}, "\n";
>
> Ergibt:
>
> 23
> 42
>
> die beiden sind also offensichtlich nicht äquivalent (wäre auch
> unlogisch - warum sollte die indirekte Klammerung gerade 2 von 3
> Indirektionen umfassen und nicht alle oder keine?).
>
> print ${$r_Programm}{PUNKTELISTE}[1]{JOINT_SPEED}, "\n";
> print $r_Programm->{PUNKTELISTE}[1]{JOINT_SPEED}, "\n";
>
> ergeben beide 23, sind also äquivalent zur Form des OP. Ich halte die
> letzte Form für die lesbarste.

Ah, ich hab die Referenz dann doch mit einem Hash
verwechselt, obwohl ich es zu Beginn noch richtig gesehen
hatte...

Spitzenbeispiel warum solche Strukturen nicht so toll sind und dass
man die Schreibweise nicht abkürzen sollte :)

Re: Komplexe Datenstrukturen vereinfachen

Philipp E. Letschert:

> Ah, ich hab die Referenz dann doch mit einem Hash
> verwechselt, obwohl ich es zu Beginn noch richtig gesehen
> hatte...
>
> Spitzenbeispiel warum solche Strukturen nicht so toll sind und dass
> man die Schreibweise nicht abkürzen sollte :)

Module wie Date::Dumper oder der Backend-Decompiler B::Deparse
können hier Einiges an Aufklärungsarbeit leisten, indem sie solche
Strukturen schöner visualisiert darstellen... Verwendung empfohlen!

LG, Ferry

--
Ing Ferry Bolhar
Magistrat der Stadt Wien - MA 14
A-1010 Wien
E-Mail: bol@adv.magwien.gv.at

Re: Komplexe Datenstrukturen vereinfachen

Ferry Bolhar schrieb:

> Date::Dumper

s/Date/Data/;

SCNR,

Joergen

Re: Komplexe Datenstrukturen vereinfachen

"Ferry Bolhar" writes:

> Philipp E. Letschert:
>
> > Ah, ich hab die Referenz dann doch mit einem Hash
> > verwechselt, obwohl ich es zu Beginn noch richtig gesehen
> > hatte...
> >
> > Spitzenbeispiel warum solche Strukturen nicht so toll sind und dass
> > man die Schreibweise nicht abkürzen sollte :)
>
> Module wie Date::Dumper oder der Backend-Decompiler B::Deparse
> können hier Einiges an Aufklärungsarbeit leisten, indem sie solche
> Strukturen schöner visualisiert darstellen... Verwendung empfohlen!

Kürzlich habe ich probehalber ein Emacs-Makro zum Debuggen von
Data::Dumper auf YAML/YAML::Syck umgestellt. Mal sehen, ob es mir
gefallen wird...

--
Slaven Rezic - slaven rezic de

Start a WWW browser - OS independent:
http://user.cs.tu-berlin.de/~eserte/src/perl/WWWBrowser/