|< 1 2 >| | 13 Einträge, 2 Seiten |
$user->user
$user->user('anne')
$user->duration->add(1)
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
69
70
71
#!/usr/bin/perl
use warnings;
use strict;
use constant TRUE => 1;
use constant FALSE => 0;
use FindBin qw($Bin);
{ package user::name;
sub new {
my $class = shift;
my $name = shift;
bless \$name, $class;
}
sub get {
my $self = shift;
return $$self;
}
sub set {
my $self = shift;
$$self = shift;
}
}
{ package user::password;
sub new {
my $class = shift;
my $password = shift;
bless \$password, $class;
}
sub get {
my $self = shift;
return $$self;
}
sub set {
my $self = shift;
$$self = shift;
}
}
{ package user;
sub new {
my $self = bless {}, shift;
my %options = @_;
$self->{name} = user::name->new ( $options{name} );
$self->{password} = user::password->new( $options{password} );
return $self;
}
sub name {
my $self = shift;
$self->{name};
}
sub password {
my $self = shift;
$self->{password};
}
}
my $paul = user->new(
name => 'paul',
password => 'passwd' ,
);
my $anne = user->new(
name => 'anne',
password => 'nopwd',
);
print $paul->name->get, "\n", $paul->password->get, "\n";
print "\n";
print $anne->name->get, "\n", $anne->password->get, "\n";
Quotealso mir kommt dein aufwand übertrieben vor.
Quotedu möchtest dir die arbeit sparen, add_* methoden zu schreiben, musst
aber letztendlich doch für jede attribut-klasse so eine methode schreiben,
und jetzt sagst du, du möchtest dir sparen, die accessor-methoden
zu schreiben. da hätte ich zuerst angefagen zu sparen, und da
gibt es auch schon lange module für, die dir das abnehmen (eben z.B.
Class::Accessor). und wenn du es selbst machst,
solltest du auch nicht eval nehmen (ich vermute, du meintest
string-eval), sondern das ist in der regel für sowas unnötig. methoden
kannst du einfach mit *$subname = sub { my ($self) ... }
anlegen.
Quotewie gesagt, dein ansatz kommt mir sehr kompliziert vor, und ich habe auch noch nicht begriffen, was du dir dadurch letzendlich sparst.
Quotezudem finde ich, dass ein attribut nur dann selbst ein objekt sein
sollte, wenn es mehr als nureine zahl oder ein string ist. eben
wenn es selbst attribute hat. aus einfachen zahlen-attributen objekte zu
machen, hat auch noch den nachteil, dass es alles langsamer macht.
ein einziger zugriff muss nun plötzlich 2 methoden aufrufen statt einer.
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
{ package user;
{ #start lexical scope
my @class_attributes = qw/ name password /;
no strict 'refs';
for my $attribute ( @class_attributes ) {
# Create new Package with Overload
eval 'package '.__PACKAGE__.'::'.$attribute.';'.'use overload \'""\' => \&get;';
# Create method new for new package
*{__PACKAGE__.'::'.$attribute.'::'.'new'} = sub {
die "Not enough Paramters" if @_ < 2;
bless \$_[1], $_[0];
};
# Create method set/get for new package
*{__PACKAGE__.'::'.$attribute.'::'.'get'} = sub { return ${$_[0]} };
*{__PACKAGE__.'::'.$attribute.'::'.'set'} = sub { ${$_[0]} = $_[1] };
# Create Methods in this package to Call the Classes
*{$attribute} = sub {
my $self = shift;
if (@_) { $self->{$attribute}->set(@_) }
else { $self->{$attribute} }
};
}
} #end lexical scope
sub new {
my $self = bless {}, shift;
my %options = @_;
$self->{name} = user::name->new ( $options{name} );
$self->{password} = user::password->new( $options{password} );
return $self;
}
}
my $paul = user->new;
$paul->name("Paulchen");
$paul->password("123456");
my $anne = new user;
$anne->name("anne");
$anne->password("654321");
print $paul->name, "\n", $paul->password, "\n";
print "\n";
print $anne->name, "\n", $anne->password, "\n";
Quoteich finde deinen ansatz immer noch zu kompliziert und du hast immer noch nicht gesaagt, was du gewinnst.
Quoteduration->add viel schlechter. wenn dann inc, denn duration ist ja nur eine zahl. dass du was hinzufügst, gehört IMHO von der logik her in die ursprüngliche klasse.
1
2
3
4
5
6
7
8
9
package User;
use strict;
use warnings;
use base 'Class::Accessor';
User->mk_accessors(qw/name passwort/);
1;
1
2
3
4
5
6
7
8
9
10
#!/usr/bin/perl
use strict;
use warnings;
use User;
my $user = User->new();
$user->name('test');
print $user->name();
QuoteLetztendlich ist es das gleiche wie in anderen programmiersprachen, wo ich einfach nochmals hinten dran einfach eine methode aufrufen kann.
QuoteKlar könnte ich das auch machen. Man könnte auch "net_ftp_connect" schreiben anstatt extra ein namespace zu benutzen. Und dann wieder zurück richtung C gehen oder so wie es PHP macht.
QuoteWenn ich 1 Tag hinzuaddieren. Warum sollte dies zu User gehören. Warum sollte diese Methode auch für "name", "password", "email" zur Verfügung stehen? Diese Methode hat doch gar nichts mit den anderen Attributen zu tun. Und ist speziell eine Methode nur für dieses Attribut.
QuoteDas man letztendlich aber eine Klasse hat die nur ein Attribut beinhaltet finde ich ebenso unschön. Von mir aus muss es ja auch nicht so sein das ich wiederrum Klassen benutze. Ich würde auch eine andere Weg benutzen. Ein anderer Fällt mir aber nicht ein.
1
2
3
4
5
6
7
8
9
package User;
use strict;
use warnings;
use base 'Class::Accessor';
User->mk_accessors(qw/name passwort/);
1;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
package User;
use strict;
use warnings;
use base 'Class::Accessor';
# User->follow_best_practice; # get_* und set_*
User->mk_accessors(qw/name passwort duration/);
sub add_duration {
$_[0]->duration(
$_[0]->duration() + $_[1]
);
}
1;
|< 1 2 >| | 13 Einträge, 2 Seiten |