Schrift
Wiki:Tipp zum Debugging: use Data::Dumper; local $Data::Dumper::Useqq = 1; print Dumper \@var;
Start · Board · Anwendungen/Programme/Skripte in Perl · Allgemeines zu Perl
[thread]5786[/thread]

Perl +OOP

Tags: Ähnliche Threads

Leser: 2


<< |< 1 2 3 >| >> 27 Einträge, 3 Seiten
[HR]Doomrunner
 2003-10-01 14:23
#59441 #59441
User since
2003-09-04
77 Artikel
BenutzerIn
[default_avatar]
Hi,

ich habe mir jetzt heute mal das OOP Tutorial von Selfhtml reingezogen. Ich finde das ja ziemlich interessant, doch ich frage mich, ob ich das überhaupt brauche. Soweit ich das bisher gesehen habe, kann ich all das, was die Objekte und Instanzen machen auch über Subroutines mit Parametern machen, oder?

Für welche Zwecke haltet Ihr OOP für Vorteilhafter? Habt ihr noch gute Tutorials zu diesem Thema?
pq
 2003-10-01 14:50
#59442 #59442
User since
2003-08-04
12208 Artikel
Admin1
[Homepage]
user image
ich kann da nur Damian Conway: Object Oriented Perl empfehlen.
sicher lässt sich jedes programm auch in nicht-OOP schreiben, aber es wird
unter umständen viel mehr code sein.
je nach problemstellung kannst du durch vererbung eine menge überflüssigen
code einsparen; durch die kapselung in klassen fällt es ausserdem leichter,
dem code später etwas hinzuzufügen.
naja wie gesagt, das buch ist sehr aufschlussreich.
ansonsten: es gibt ja immer auch noch perldoc, hast du denn da noch gar nicht
reingeschaut? dort gibt es 4 manpages zu dem thema (perlboot, perltoot,
perltooc, perlbot)
Always code as if the guy who ends up maintaining your code will be a violent psychopath who knows where you live. -- Damian Conway in "Perl Best Practices"
lesen: Wiki:Wie frage ich & perlintro Wiki:brian's Leitfaden für jedes Perl-Problem
Strat
 2003-10-01 15:14
#59443 #59443
User since
2003-08-04
5246 Artikel
ModeratorIn
[Homepage] [default_avatar]
OOP muss man fast immer verwenden, wenn man Module, die nur ein OOP-Interface zur verfuegung stellen, benuetzt.
OOP sollte man verwenden, wenn man Daten und die darauf angewendete Funktionalitaet in Gruppen (=Klassen) zusammenfassen will, z.b. wenn man ein Zeichenprogramm hat, das Klassen wie Punkt, Rechteck, Kreis usw. hat, kann man dann einfach sagen:
$punkt->zeichneDich();
$kreis->zeichneDich();
und du hast fuer jedes Objekt ($punkt, $kreis, ...) unterschiedliche Methoden (zeichneDich), die jedoch alle gleich heissen. Welche davon aufgerufen wird, weiss Perl schon durch das Objekt.
Bei prozeduraler Programmierung muesstest du sonst schreiben:
&zeichneDichAlsPunkt($punkt);
&zeichneDichAlsKreis($kreis);
oder in zeichneDich() immer abfragen, was da reinkommt, was der Prozedur zeichneDich() unnoetig viel Code beschert, und eine eventuelle Erweiterung erschwert, weil du da immer auf alle Elemente Ruecksicht nehmen musst, waehrend du bei OOP immer in derselben Klasse bleibst.
Weiters hast du bei OOP auch das Konzept der Vererbung. Du koenntest z.B. eine Klasse namens Punkt machen, die eine bestimmte Funktionalitaet hat. Davon leitest du eine Klasse namens Strich ab, die einige Funktionalitaet von Punkt erbt, andere aber ueberschreibt oder erweitert. Von Strich koenntest du z.B. Rechteck, Kreis, Oval, ... ableiten...
perl -le "s::*erlco'unaty.'.dk':e,y;*kn:ai;penmic;;print"
http://www.fabiani.net/
[HR]Doomrunner
 2003-10-01 15:18
#59444 #59444
User since
2003-09-04
77 Artikel
BenutzerIn
[default_avatar]
Hi,

ich habe mir jetzt einfach mal ein Package geschrieben, dass mir das Datum vernünftig ermittelt. Das lasse ich dann anschließend mit meinem Perl-Script ausgeben. Schaut euch das bitte mal an und sagt mir, ob das so im Sinne der OOP ist:

Das Package:
Code (perl): (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

package crs;

sub new {
        my $objekt = shift;
        my $referenz = {};
        bless($referenz,$objekt);
        return($referenz);
}

sub datum {
        my $objekt = shift;
        my $schluessel = shift;
        
        my $zeit = localtime(time);
        my ($wochentag, $monat, $tag, $uhrzeit, $jahr) = split(/ +/,$zeit);
        
        $monat = $objekt->monatzahl($monat);
        
        $objekt->{wochentag} = $wochentag;
        $objekt->{tag} = $tag;
        $objekt->{monat} = $monat;
        $objekt->{jahr} = $jahr;
        $objekt->{uhrzeit} = $uhrzeit;
        
        return($objekt->{$schluessel});
}

sub monatzahl {
        my $objekt = shift;
        my $monat = shift;
        
        $monat =~ s/Jan/1/;
        $monat =~ s/Feb/2/;
        $monat =~ s/Mar/3/;
        $monat =~ s/Apr/4/;
        $monat =~ s/May/5/;
        $monat =~ s/Jun/6/;
        $monat =~ s/Jul/7/;
        $monat =~ s/Aug/8/;
        $monat =~ s/Sep/9/;
        $monat =~ s/Oct/10/;
        $monat =~ s/Nov/11/;
        $monat =~ s/Dec/12/;
        
        return($monat);
}

1;


Das Script:
Code (perl): (dl )
1
2
3
4
5
6
7
8
9

#!perl -w

use strict;
use CGI::Carp qw(fatalsToBrowser);
use crs;
print "Content-type: text/html\n\n";

my $crs = crs -> new();
print $crs->datum("tag").".".$crs->datum("monat").".".$crs->datum("jahr");


Sorry, dass der Quellcode nicht eingerückt ist, aber er scheint die Tabulatoren hier im Forum nicht zu übernehmen.
format_c
 2003-10-01 16:33
#59445 #59445
User since
2003-08-04
1706 Artikel
HausmeisterIn
[Homepage] [default_avatar]
Und was solldas machen? 01.10.2003? Ich kann OOP nicht so gut lesen. Hab mich noch nicht damit beschäftigen.
Effizente Linuxshell
[HR]Doomrunner
 2003-10-01 16:38
#59446 #59446
User since
2003-09-04
77 Artikel
BenutzerIn
[default_avatar]
Ja, das ist das Ergebnis, das ausgegeben wird.

Mir geht es darum meine Perl-Scripte demnächst in OOP zu machen.

Ab nun muß ich fürs Datum z.B. nur noch das Package einbinden und kann schon mit 2 Zeilen aufs Datum zugreifen. Das hat doch was, oder nicht?

Die Frage ist, ob das so schon im OOP Sinne ist.
Strat
 2003-10-01 16:40
#59447 #59447
User since
2003-08-04
5246 Artikel
ModeratorIn
[Homepage] [default_avatar]
ich bin mir nicht sicher, ob da oop der beste ansatz fuer sowas ist...
Nebenbei: wenn du localtime in einem Listenkontext verwendest, bekommst du eine Liste zurueck und keine englische Zeichenkette, die vielleicht sogar von Maschine zu Maschine variieren kann... z.B.
Code: (dl )
1
2
3
4
my %date;
@date{ qw(day month year weekday) } = ( localtime(time) )[3..6];
$date{month}++;
$date{year} += 1900;


Es gibt aber bereits fertige Module fuer sowas, z.B.
Code: (dl )
1
2
3
use Time::localtime;
my $tm = localtime;
$tm->mday, $tm->mon + 1, $tm->year + 1900, ...
perl -le "s::*erlco'unaty.'.dk':e,y;*kn:ai;penmic;;print"
http://www.fabiani.net/
format_c
 2003-10-01 16:42
#59448 #59448
User since
2003-08-04
1706 Artikel
HausmeisterIn
[Homepage] [default_avatar]
Das mach ich dir auch in zwei Anweisungen. Wenn ich ganz speichereffizient sein will drei.


Gruß alex
Effizente Linuxshell
[HR]Doomrunner
 2003-10-01 16:49
#59449 #59449
User since
2003-09-04
77 Artikel
BenutzerIn
[default_avatar]
Ich weiss auch, dass es bereits ein Modul für die Zeitausgabe gibt.

Mir gehts erstmal darum in die OOP-Geschichte hereinzukommen. Deshalb habe ich mir was simples genommen. Bisher sehe ich da allerdings noch keine Vorteile. Das kann ich mit subroutines genauso machen. Geht dann sogar noch schneller.
DS
 2003-10-01 23:33
#59450 #59450
User since
2003-08-04
247 Artikel
BenutzerIn
[default_avatar]
Ich hab' das Ding spaßhalber mal ein bisserl umgeschreiben:

Code (perl): (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

package crs;

my @wochentage = qw/Sonntag Montag Dienstag Mittwoch Donnerstag Freitag Samstag/;

*new = *neu; # *unauffälligpfeif*
sub neu {
  my $klasse = shift;
  return bless(&jetzt,ref($klasse) || $klasse || _ _PACKAGE_ _);
}

sub AUTOLOAD {
  my $ich = ref($_[0]) ? shift : &jetzt;
  $AUTOLOAD =~ s/^.+\:\://;
  defined($ich->{$AUTOLOAD}) || die "Eigenschaft '$AUTOLOAD' nicht definiert!";
  return $ich->{$AUTOLOAD};
}

sub jetzt {
  my @z = localtime(time);
  my $ich = {
   sekunden      => $z[0],
   minuten       => $z[1],
   stunden       => $z[2],
   tag           => $z[3],
   monat         => $z[4]+1,
   jahr          => $z[5]+1900,
   wochentag     => $wochentage[$z[6]]
  };
  $ich->{uhrzeit} = $ich->{stunden}.':'.$ich->{minuten}.':'.$ich->{sekunden};
  $ich->{datum} = $ich->{tag}.'.'.$ich->{monat}.'.'.$ich->{jahr};
  return $ich;
}

1;

So wird's aufgerufen:

Code (perl): (dl )
1
2
3
4
5
6
7

#!perl

use crs;

my $blablabla = new crs;
print $blablabla->datum."
".crs->uhrzeit;

Naja, ich finde die OOP (u.a.) praktisch, weil (u.a.) die Funktionen (dann Methoden), die zu einem bestimmten meist komplexeren Datengebilde gehören, direkt bei diesem dabei sind, was das Ganze einfacher zu schreiben und zu lesen macht (oder zumindest machen sollte ;)). Daß es (wie bei einigen anderen Programmiersprachen ja auch) auf Kosten der Geschwindigkeit geht, ist natürlich ned so schön; da muß man halt abwägen, wo man optimieren muß/sollte/kann, bzw. sogar auf OOP verzichten sollte.

Edit: Das Forum mag mich Mit-Einem-Leerzeichen-Einrücker ned...
Edit die 4.: *irgendwanngehtes...ganzsicher...ichmußnurganzfestdaranglauben*
Edit die 6.: Warum mag er _ _PACKAGE_ _ ned?
Edit die 7.: Warum mag er es auch im normalen Text nicht?
Hinweis der 1.: Überall wo _ _PACKAGE_ _ steht bitte die beiden Leezeichen zwischen den Unterstrichen rausdenken...\n\n

<!--EDIT|DS|1065037326-->
<< |< 1 2 3 >| >> 27 Einträge, 3 Seiten



View all threads created 2003-10-01 14:23.