Schrift
Start · Board · Anwendungen/Programme/Skripte in Perl · Allgemeines zu Perl
[thread]11069[/thread]

Hashref bei anonymer Funktion (Seite 2)



<< |< 1 2 3 >| >> 26 Einträge, 3 Seiten
Froschpopo
 2007-12-28 11:00
#104177 #104177
User since
2003-08-15
2653 Artikel
BenutzerIn
[default_avatar]
Code (perl): (dl )
1
2
3
4
5

1: my $hashref = sub {
2:     return int(rand(1000));
3: };
4: print $hashref->(),"\n";
5: print $hashref->(),"\n";  #ergibt dasselbe ergebnis wie beim ersten print()

Wenn $hashref zweimal ausgeführt wird, warum ist dann das Ergebnis beide Male dasselbe?
Linuxer
 2007-12-28 11:06
#104178 #104178
User since
2006-01-27
3891 Artikel
HausmeisterIn

user image
Wenn $hashref zweimal ausgeführt wird, warum ist dann das Ergebnis beide Male dasselbe?

Hier nicht... (WinXP, ActivePerl Build 817 [257965])

Code: (dl )
1
2
3
4
5
my $ref = sub { return int rand 1000; };
print $ref->(), $/;
print $ref->(), $/;
646
777


Kann Deine Aussage nicht nachvollziehen... Gemäß Theorie sollten unterschiedliche Werte rauskommen (gut auch bei einem Zufallswert kann 2mal der gleiche Wert auftauchen; das ist dann Zufall ;o) ).
meine Beiträge: I.d.R. alle Angaben ohne Gewähr und auf Linux abgestimmt!
Die Sprache heisst Perl, nicht PERL. - Bitte Crossposts als solche kenntlich machen!
Froschpopo
 2007-12-28 11:10
#104179 #104179
User since
2003-08-15
2653 Artikel
BenutzerIn
[default_avatar]
@Struppel
Wenn ich dich richtig verstehe, dann wird die Funktion durch ->() ausgeführt und wenn ich dieses schon bei der deklarierung des Scalars anwende, wird daraus so eine Art "statische Funktion".
Froschpopo
 2007-12-28 11:17
#104181 #104181
User since
2003-08-15
2653 Artikel
BenutzerIn
[default_avatar]
@Linuxer

Es gibt tatsächlich nur darum, dass ich innerhalb einer Funktion mehrere my-Variablen mit gleichem Name nutzen will.

Wenns nach mir ginge, dann hätte ich am liebsten sowas wie:

Code (perl): (dl )
1
2
3
4
5
6
7
8
9
10
11

sub funktion {
   {
       my $sth = ...
       , \%results
    }

   {
       my $sth = ...
       , \%results
    }
}

Mir gehen langsam nämlich die Namen für SQl-Statements aus. Teilweise muss ich immer erstmal überlegen, was Handle, Statement, Ergebnisse usw. ist.
Deshalb habe ich beschlossen, nur noch "$stmt, $sth, %results, $results" zu verwenden um den Überblick zu behalten.
Wenn ich also $sth sehe, weiss ich sofort ohne zu überlegen, dass es ein Handle ist.
Bisher hab ich immer so einen Kram gemacht:
my $fotos_handle
my $user_handle
usw.
Froschpopo
 2007-12-28 11:45
#104183 #104183
User since
2003-08-15
2653 Artikel
BenutzerIn
[default_avatar]
wirds in Perl6 eigentlich auch noch möglich sein, anonyme Funktionen auf diese Weise zu bilden?
Linuxer
 2007-12-28 11:50
#104184 #104184
User since
2006-01-27
3891 Artikel
HausmeisterIn

user image
Hi,

Warum kannst Du "$sth" als Handle erkennen, "$foto_handle" aber nicht?
Die Idee finde ich gar nicht mal so schlecht, die Funktion des Skalars als Postfix an den Namen zu hängen:
Code: (dl )
$foto_handle = ... $foto_stmt ...;

oder
Code: (dl )
$foto_sth = ... $foto_stmt ...;


Wenn Du einen Hash einsetzt, dann siehst Du sogar zuerst die Funktion...
Code: (dl )
$sth{foto} = ... $stmt{foto} ...;


wenn Du schon einzelne Bereiche in Blöcke definieren willst/kannst, spricht nur noch wenig dagegen, diese Blöcke in eigene Subs auszulagern.
Somit hast Du dann letzten Endes pro Sub z.B. nur ein Handle...

Vielleicht fehlt dem Code auch insgesamt eine passende Struktur, um dieses Problem zu lösen?



meine Beiträge: I.d.R. alle Angaben ohne Gewähr und auf Linux abgestimmt!
Die Sprache heisst Perl, nicht PERL. - Bitte Crossposts als solche kenntlich machen!
Froschpopo
 2007-12-28 11:58
#104185 #104185
User since
2003-08-15
2653 Artikel
BenutzerIn
[default_avatar]
wenn ich eigene Subs mache, dann muss ich ja jadesmal die Parameter mitschleppen und diese dann erstmal wieder einbeziehen, was einiges an Schreibarbeit ist. Wenn ich diese ohnehin sehr kleinen Funktionen einfach dort einbette, wo ich sie brauche, dann kann ich die "Mutter"-variablen von funktion() benutzen, was das ganze erheblich vereinfacht.

Zu der Sache mit dem Hash:
Ich verwende solche Hashes ganz gern bei Tk-Anwendungen, nämlich z.B. für MainWindow usw.
Aber ich finde es schwierig, den Überblick über einen Hash zu behalten weil da kein strict meckert, wenn ich z.b. einen Tippfehler oder sowas drinne hab.
Man muss dann jedesmal erstmal die ganzen keys prüfen und gucken, ob sich der gesuchte key überhaupt im Hash befindet.
Deshalb lagere ich die wichtigsten Sachen (z.B. Datenbankhandle, Objekte etc.) meistens in eine Art "Config-Modul" aus, dessen Objektreferenz ich dann im ganzen Main-Script durch die ganzen Funktionen mitschleife.

Zu der Namensgebung:
Du musst dir ja noch viel mehr namen einfallen lassen.
Angenommen, du willst wissen, wer von deiner Buddyliste blockiert wird. Dann brauchst du
$buddylist_blocked_users_stmt,
$buddylist_blocked_users_handle,
@buddylist_blocked_users_results,
usw.
Das ist mir irgendwann zu blöd, weil du dann erstmal gucken musst, was die Variable beschreibt und was die Zugriffs-Art deklariert usw.
Struppi
 2007-12-28 12:58
#104192 #104192
User since
2006-02-17
628 Artikel
BenutzerIn
[Homepage]
user image
Froschpopo+2007-12-28 10:58:00--
wenn ich eigene Subs mache, dann muss ich ja jadesmal die Parameter mitschleppen und diese dann erstmal wieder einbeziehen, was einiges an Schreibarbeit ist. Wenn ich diese ohnehin sehr kleinen Funktionen einfach dort einbette, wo ich sie brauche, dann kann ich die "Mutter"-variablen von funktion() benutzen, was das ganze erheblich vereinfacht.
Das verstehe ich nicht? Ich verstehe auch nicht, wofür du die vielen Variabeln brauchst. Und was du mit Parameter mitschleppen meinst ist mir auch nicht klar. Wenn ich mich recht erinnere Arbeitest du doch Modular, d.h. du kannst einen Modulweite Variabel an einer Stelle deklarieren.

Da wir jetzt aber nur Fragemente kennen läßt sich nur schwer sagen was am sinnvollsten ist. So wie du es jetzt machst ist es mit Sicherheit nicht sinnvoll.
Froschpopo
 2007-12-28 13:55
#104203 #104203
User since
2003-08-15
2653 Artikel
BenutzerIn
[default_avatar]
ich brauche ca. 10 Statements innerhalb einer Funktion. Wenn ich jedes Statement in eine eigene Sub auslagere, wirds zuviel Code, weil die vielen Parameter in den Subs erstmal entgegengenommen werden müssen (shift, @_, usw.).
ich brauche schließlich in jeder Sub das Datenbankhandle welches ich in $dbh festhalte.

Das sieht dann teilweise so aus (man beachte die Nummern)
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

sub profile {
   my ($dbh, $sql, $cgi, $cache) = @_;
   my $first_name = $cgi->param(...);
   my $last_name = $cgi->param(...);
   my $city_name = $cgi->param(...);
   my $tier_name = $cgi->param(...);
   my $phone_prv = $cgi->param(...);
   my $phone_mbi = $cgi->param(...);
   my $phone_biz = $cgi->param(...);

   # hier entstehen viele weiter Variablen, nicht alle aus $cgi, viele auch aus Unterprozessen, Abfragen und Rechenergebnisse.

   my @fields = (...);
   my %where = (...);
   my @tables = (...);
   my @order = (...);
   my ($stmt, @bind) = $sql->select(\@tables, \@fields, \%where, \@order);
   my $sth = $dbh->prepare($stmt);
   $sth->execute(@bind)
       or die $errors->output($DBI::errstr);

   my @fields2 = (...);
   my %where2 = (...);
   my @tables2 = (...);
   my @order2 = (...);
   my ($stmt2, @bind2) = $sql->select(\@tables2, \@fields2, \%where2, \@order2);
   my $sth2 = $dbh->prepare($stmt2);
   $sth2->execute(@bind2)
      or die $errors->output($DBI::errstr);
 
   my @fields3 = (...);
   my %where3 = (...);
   my @tables3 = (...);
   my @order3 = (...);
   my ($stmt3, @bind3) = $sql->select(\@tables3, \@fields3, \%where3, \@order3);
   my $sth3 = $dbh->prepare($stmt3);
   $sth3->execute(@bind3)
       or die $errors->output($DBI::errstr);
}


INNERHALB der profile() werden einige Variablen erschaffen, die ich, wenn ich die Abfrage in eine anonyme Sub einbette, nutzen kann.
Würde ich für jede Abfrage eine eigene Sub machen, müsste ich ettliche Variablen als Parameter übergeben. Dabei gibt es Reihenfolgen einzuhalten, sie müssen benannt werden etc.
Da ist es einfacher, die oben einzubetten, insbesondere deshalb, weil die Abfragen selbst relativ klein sind und sich meistens auf ca. 30 Zeilen beschränken.
Struppi
 2007-12-28 14:19
#104205 #104205
User since
2006-02-17
628 Artikel
BenutzerIn
[Homepage]
user image
Also nicht Modular?
Wann holst du dir denn die Daten?

Ich habe mir für exakt sowas ein Modul gebaut, in dem $dbh ein Modulattribut ist, auch die ganzen Handler benötige ich nicht, da ich mir lediglich die Ergebnismenge als Hash zurückgeben lasse, dass istz ja genau das was du eigentlich willst.
Ich weiß ja nicht was $sql ist, aber diese ganze Geschichte:
Code (perl): (dl )
1
2
3
4

    my ($stmt2, @bind2) = $sql->select(\@tables2, \@fields2, \%where2, \@order2);
27:    my $sth2 = $dbh->prepare($stmt2);
28:    $sth2->execute(@bind2)
29:       or die $errors->output($DBI::errstr);

kann man Prima zusammenfassen in ein Modul.

Das ganze sieht auch irgendwie aus, als ob du dich mal mit joins beschäftigen solltest, damit kannst du mehrere zusammenhängende Tabellen verknüpfen, dass ist eine der Stärken eine SQL Datenbank.
<< |< 1 2 3 >| >> 26 Einträge, 3 Seiten



View all threads created 2007-12-28 05:40.