Array-Referenzen

[Gustl]

Hi all !

Also es liegen mir in $ref Array-Referenzen auf Array-Referenzen vor.

push(@inhalt,@{$ref});

Gebe ich die Liste @inhalt aus, so sehe ich wieder Array-Referenzen. Jetzt dachte ich mir ich schreib´s so:

push(@inhalt,@{@{$ref}}); Ne, so nicht sagt strict.

Wie krieg ich den Inhalt von $ref (nicht als Referenz) in @inhalt gepuscht - ohne Schleife ?

Gruss Gustl

[Struppi]

Wie krieg ich den Inhalt von $ref (nicht als Referenz) in @inhalt gepuscht - ohne Schleife ?

gar nicht. du musst jedes Element dereferenzieren.

Struppi.

[Gustl]

Guten Morgen. Es ist jetzt 00:20:23:44:17 UTC

Wie krieg ich den Inhalt von $ref (nicht als Referenz) in @inhalt gepuscht - ohne Schleife ?

gar nicht. du musst jedes Element dereferenzieren.

Hi Struppi, also das meinte ich letztens mit umständlich aufdröseln ... in Sachen DBI.

Also die ganze Anweisung:

  
my $ref=$select->fetchall_arrayref;  
my @inh=@{$ref};  
my @inhalt;  
foreach my $rz (@inh) { push(@inhalt,@{$rz}); }  

Es wurmt mich dass ich das nicht einfacher scheiben kann.

Gruss Gustl

[Struppi]

Also die ganze Anweisung:

[code lang=perl]
my $ref=$select->fetchall_arrayref;
my @inh=@{$ref};

Hier hast du doch dein Array?
Es geht auch: my @inh = @$ref;
Aber warum? Du hast damit das Array doppelt im Speicher

Struppi.

[Gustl]

Hier hast du doch dein Array?

Ja - indem jetzt die einzelnen Referenzen stehen ...

Es geht auch: my @inh = @$ref;

Ja.

Aber warum? Du hast damit das Array doppelt im Speicher

Ironisch: Hab ja genug Speicher haha :)

Ich seh halt im Moment keinen anderen Weg, deshalb ja der Thread.

$ref ist eine Referenz auf Referenzen. @inh = @$ref; zerlegt die Referenz in die einzelnen Referenzen. In @inh stehen also nun x Datensätze, widerum als Referenz, die ich noch nicht wie gewünscht verarbeiten kann. Ich muss also diese "Referenzliste" widerum "aufdröseln", in eine zweite Liste bringen und musste dazu ne Schleife schreiben.

Was anderes ist mir eben nicht eingefallen. Meine Frage war wie es anders besser geht. Hmmm ...

Von Anfang an: Ich hol mir aus der SQL-Tabelle pro Datensatz 2 Werte.

my $selinh=$dbh->prepare('SELECT akz1,akz2 FROM inhalt') || die $DBI::errstr;  
  
$selinh->execute || die $DBI::errstr;

akz1 und akz2 sind Autokennzeichen. Diese Werte sind unterschiedlich oder nicht. Dann:

my $ref=$selinh->fetchall_arrayref;

Jetzt hab die Referenz auf die Referenzen in $ref. @inhalt muss nun alle AKZ´s einzeln beinhalten, damit ich den Hash entsprechend füttern kann.

[dieFragedesThreads] my @inhalt = Füttern mit Einzelwerten nicht als Referenzen.

Als nächsten Schritt muss ich doppelt vorkommende Strings entfernen und die Vorkommen zählen.

my %saw; grep !$saw{( split/;/,$_)[0]}++ , @inhalt;

Im Hash %saw steht als Name nun die Anzahl von Vorkommen und in Wert das Vorkommen. Aus diesen Werten bau ich eine Optionlist.

  
print "<select name=akz>";  
  
while (my ($v1, $v2) = each %saw)  
{  
  my $sel;  
  
  if ($akz eq $v1)  
  {  
    $sel="selected";  
  }  
    else  
  {  
    $sel="";  
  }  
  
  print "<option value=\"$v1\" $sel>$v1 [ $v2 ]</option>";  
}  
  
print"</select>";

Diese widerum kann dann zur Auswahl eines Kennzeichens benutzt werden, pro Kennzeichen steht auch schön die Anzahl der Datensätze pro Kennzeichen usw usw ...

Die Frage: Wie zerlege ich $ref am besten hab ich seit des DBI Threads. Ich verstehe auch den Sinn nicht warum es keine Möglichkeit gibt gleich von Anfang an mit -man verzeihe mir- "brauchbaren Werten" zu arbeiten. Das zerlegen von $ref ist ja nicht vermeidbar wenn man die Daten verarbeiten und ausgeben will. Warum also dieser "Umweg".

Also entweder ist schon der Ansatz fetchall_arrayref falsch oder was.

Gruss Gustl

[Struppi]

Hier hast du doch dein Array?

Ja - indem jetzt die einzelnen Referenzen stehen ...

Genau. Aber das wird auch nicht durch das doppelte array anders.

Es geht auch: my @inh = @$ref;

Ja.

Aber warum? Du hast damit das Array doppelt im Speicher

Ironisch: Hab ja genug Speicher haha :)

Naja, in deiner Abfrage ist keine Begrenzung, d.h. es werden zwei Spalten der kompletten Tabelle in den Speicher geladen, das kann sehr viel sein.

Ich seh halt im Moment keinen anderen Weg, deshalb ja der Thread.

$ref ist eine Referenz auf Referenzen. @inh = @$ref; zerlegt die Referenz in die einzelnen Referenzen.

Das stimmt nicht. Das einzige was du machst, du kopierst die Array Referenz in das Array, aber der Inhalt des Array ändert sich nicht.

Was anderes ist mir eben nicht eingefallen. Meine Frage war wie es anders besser geht. Hmmm ...

Das würde ich auch bevorzugen, momentan bist du auf dem Holzweg. Hast du dir eigentlich schon mal perldoc angeschaut? Da gibt es einige Dokumente über Referenzen und Listen von Referenzen. Ohne das du diese gelesen hast, wirst du nicht weiter kommen.

my $ref=$selinh->fetchall_arrayref;

Jetzt hab die Referenz auf die Referenzen in $ref. @inhalt muss nun alle AKZ´s einzeln beinhalten, damit ich den Hash entsprechend füttern kann.

Welchen Hash?
Evtl. willst du gar nicht fetchall sondern irgendeine andere fetch funktion des DBI Moduls verwenden.

Als nächsten Schritt muss ich doppelt vorkommende Strings entfernen und die Vorkommen zählen.

Das klingt mir eher nach einer Aufgabe für die SQL Abfrage. z.b. mit group by

while (my ($v1, $v2) = each %saw)

sowas kann man ürbigens sehr schön und wesntlich lesbarer mit dem CGI Modul machen, dort gibt es eine Funktion popup_menu() mit dem man Auswahlisten mit Hilfe von Perl Datenstrukturen dynamisch ausgeben kann.

Die Frage: Wie zerlege ich $ref am besten hab ich seit des DBI Threads. Ich verstehe auch den Sinn nicht warum es keine Möglichkeit gibt gleich von Anfang an mit -man verzeihe mir- "brauchbaren Werten" zu arbeiten. Das zerlegen von $ref ist ja nicht vermeidbar wenn man die Daten verarbeiten und ausgeben will. Warum also dieser "Umweg".

Das frag ich mich auch, den Umweg gehst du.

Also entweder ist schon der Ansatz fetchall_arrayref falsch oder was.

würd ich auch so sehen.

Struppi.

[Siechfred]

[dieFragedesThreads] my @inhalt = Füttern mit Einzelwerten nicht als Referenzen.

Dazu musst du die Referenz ähnlich wie einen Array einzeln durchgehen, z.B. so:

push @inhalt, @{$_->[0]} foreach(@{$ref});

Also entweder ist schon der Ansatz fetchall_arrayref falsch oder was.

Nö, nicht wirklich, aber du solltest Struppis Hinweis nach dem GROUP BY nachgehen, dann sparst du dir auf jeden Fall das Rausfiltern doppelter Einträge.

Siechfred

[Struppi]

Dazu musst du die Referenz ähnlich wie einen Array einzeln durchgehen, z.B. so:

push @inhalt, @{$_->[0]} foreach(@{$ref});

Also entweder ist schon der Ansatz fetchall_arrayref falsch oder was.

Nö, nicht wirklich, aber du solltest Struppis Hinweis nach dem GROUP BY nachgehen, dann sparst du dir auf jeden Fall das Rausfiltern doppelter Einträge.

Naja, fetchall_ bringt ja nur was, wenn man tatsächlich alle Daten verwenden möchte, da dies aber hier irgendwie nicht der Fall zu sein scheint, wäre es doch sinnvoller mit der üblichen while schleife die Daten einzulesen und zu filtern, anstatt die Daten zu verdoppeln und dann erst zu filtern.

Struppi.

[Gustl]

Naja, fetchall_ bringt ja nur was, wenn man tatsächlich alle Daten verwenden möchte

Ja das möchte ich, ich benötige alle Daten aus den selektierten Spalten akz1 und akz2.

Wir reden wieder mal komplett aneinander vorbei fürchte ich.

Grüsse Gustl

[Struppi]

Naja, fetchall_ bringt ja nur was, wenn man tatsächlich alle Daten verwenden möchte

Ja das möchte ich, ich benötige alle Daten aus den selektierten Spalten akz1 und akz2.

und die sind in deiner Array Referenz, wo ist das Problem?

Struppi.

[Gustl]

Ja das möchte ich, ich benötige alle Daten aus den selektierten Spalten akz1 und akz2.

und die sind in deiner Array Referenz, wo ist das Problem?

Hi Struppi, ja "i tschecks" wohl mal wieder nicht :) Aber das kommt schon irgendwann.

Ich habs übrigens hingekriegt, von Regensburg über Rom nach München ... ich schau mir halt gern die Welt an :)

Hab aber trotzdem wieder nebenbei einiges gelernt !

Danke, bis zum nächsten mal.

Grüsse Gustl

[Struppi]

Ja das möchte ich, ich benötige alle Daten aus den selektierten Spalten akz1 und akz2.

und die sind in deiner Array Referenz, wo ist das Problem?

Hi Struppi, ja "i tschecks" wohl mal wieder nicht :) Aber das kommt schon irgendwann.

Seltsam.

OK, dein nicht ganz optimales Beispiel (wie gesagt, die SQL Abfrage ist schon nicht gut, ich kann da aber nichts zusammen basteln, da bei mir lokal phpmyadmin nicht mehr richtig läuft)

my $selinh = $dbh->prepare('SELECT akz1,akz2 FROM inhalt') || die $DBI::errstr;  
$selinh->execute || die $DBI::errstr;  
my %saw;  
while( my $ref = $selinh->fetch_hashref)  
{  
    # wenn ich richitg verstanden habe, willst du die  
    # werte von akz1 und akz2 zählen.  
    $saw{ $ref->{akz1} = 0 unless $saw{ $ref->{akz1};  
    $saw{ $ref->{akz2} = 0 unless $saw{ $ref->{akz2};  
    $saw{ $ref->{akz1}++;  
    $saw{ $ref->{akz2}++;  
}  
  
# und die Ausgabe sähe so aus:  
print CGI::popup_menu( -name => 'akz',  -values => [keys %saw], -default => $akz, -labels => \%saw);  

Ich habs übrigens hingekriegt, von Regensburg über Rom nach München ... ich schau mir halt gern die Welt an :)

ich hoffe auch die Doku.

Struppi.

[Gustl]

Seltsam.

Mhmmm ...

und die Ausgabe sähe so aus:

print CGI::popup_menu( -name => 'akz',  -values => [keys %saw], -default => $akz, -labels => %saw);

... ich schau mir halt gern die Welt an :)

ich hoffe auch die Doku.

erwischt. ich bin zu faul. ist scheiss-anstrengend ohne genügende englisch-kenntnisse.

Hab mich übrigens mal richtig angestrengt:

my @data = map {join";",@$_} @$ref;

liefert mir in einem abwasch eine brauchbare liste jedes datensatzes. hab ich tatsächlich selbst gebaut.

mit fetch_hash, wie du schreibst könnte ich mir einen weiteren umweg sparen. und die CGI::machsgleich_fertig dinger werd ich mir auch vorknöpfen.

also heute ist mal test.pl angesagt fürchte ich.

einen Thread posten ist immer sinnvoll, egal wie blöd man ist. ich kann nur lernen. kuck mal wie gross der schon wird, da hab ich was zu lesen (und zu lernen) heute.

Grüsse Gustl

[Struppi]

und die Ausgabe sähe so aus:

print CGI::popup_menu( -name => 'akz',  -values => [keys %saw], -default => $akz, -labels => %saw);

... ich schau mir halt gern die Welt an :)

ich hoffe auch die Doku.

erwischt. ich bin zu faul. ist scheiss-anstrengend ohne genügende englisch-kenntnisse.

Gerade CGI und DBI sind Grundlagen, darüber hinaus kann man noch viel viel mehr lernen wenn man sich die Perl Doku mal vorknöpft, da steckt sauviel drin auch für Anfänger. In deinem Falle würd sich perlref mal anbieten (neben DBI und CGI)

Hab mich übrigens mal richtig angestrengt:

my @data = map {join";",@$_} @$ref;

liefert mir in einem abwasch eine brauchbare liste jedes datensatzes. hab ich tatsächlich selbst gebaut.

Wobei brauchbar, nur die halbe Wahrheit ist, da du die Daten wieder auseinander baust. wie schon mehrmals gesagt, mir ist nicht klar, warum du unbedingt fetchall und arrayref verwenden willst, wenn es sowieso nicht brauchen kannst.

Es ist durchaus üblich mit einer while() Schleife die Daten einzeln zu durchlaufen und aufzubereiten. ausserdem gibt es noch hashref, was zumindest den Code lesbarer macht (für den Preis eines gewissen Geschwindigkeitverlust)

mit fetch_hash, wie du schreibst könnte ich mir einen weiteren umweg sparen. und die CGI::machsgleich_fertig dinger werd ich mir auch vorknöpfen.

Würd ich auf jeden Fall, da man sowas immer wieder braucht und zwar sowohl  Formularelemente als auch der ganze andere HTML output (vor allem Tabellen und Listen). Der wird durch das Modul erheblich verienfacht.

einen Thread posten ist immer sinnvoll, egal wie blöd man ist. ich kann nur lernen. kuck mal wie gross der schon wird, da hab ich was zu lesen (und zu lernen) heute.

hat ja auch keiner gemeckert ;-)

Struppi.

[Gustl]

Dazu musst du die Referenz ähnlich wie einen Array einzeln durchgehen, z.B. so:

push @inhalt, @{$_->[0]} foreach(@{$ref});

Hi Siechfred,

das Ergebnis dieses Codes ist:

Can't use string ("M") as an ARRAY ref while "strict refs" in use at ...

Was GROUP BY betrifft: Ja das geht. Wobei ich widerum nicht weiss was die Anzahl der Fundstücke zurückgibt und ausserdem habe ich 2 Spalten mit Kennzeichen die ich zuerst zusammenführen müsste, dann gruppieren, endlich die Fundstücke zählen muss und letztendlich nach anzahl fundstücke oder alphabetisch sortieren sollte, dazu reich mein SQL noch nicht aus.

Da das Ding eigentlich schon so gut wie fertig ist und ich nur noch die sortierreihenfolage bestimmen muss habe ich eben beschlossen nicht wieder komplett umzubauen, auch wenns heisst dass ich ein paar umwege gehen werde.

Die "beste Lösung" wird es niemals geben.

Gruss Gustl

[Siechfred]

Can't use string ("M") as an ARRAY ref while "strict refs" in use at ...

Es war ja auch nur ein Beispiel, weshalb du dir deine Referenz mal mit Data::Dumper ausgeben lassen solltest, um die Struktur zu erkennen. Danach entscheidet sich nämlich, wie du dereferenzieren musst. Wenn du dir den Code von den 'Drei Fragezeichen' mal ansiehst, wirst du erkennen, dass da eine Referenz auf ein mehrdimensionales Array erzeugt wird, das du wie von mir beschrieben bearbeiten kannst.

Siechfred

[Gustl]

Guten Morgen. Ein neuer Tag :)

Es war ja auch nur ein Beispiel, weshalb du dir deine Referenz mal mit Data::Dumper ausgeben lassen solltest, um die Struktur zu erkennen. Danach entscheidet sich nämlich, wie du dereferenzieren musst. Wenn du dir den Code von den 'Drei Fragezeichen' mal ansiehst, wirst du erkennen, dass da eine Referenz auf ein mehrdimensionales Array erzeugt wird, das du wie von mir beschrieben bearbeiten kannst.

Ja, dass es eine Referenz auf ein mehrdimensionales Array ist weiss ich. Ich nannte es eine Referenz auf die Referenzen (im Array).

Um es zu verstehen hab ich $ref stückweise zerlegt und mir die einzelnen Ergebnisse erst mal ausgeben lassen.

Also so: (Obs klug ist sei mal dahingestellt)

$ref ausgegeben: (Array ...)

@liste (aus @$ref) in einer schleife ausgegeben: (Array ...) ... (Array ...) ... (Array ...) ... usw.

Die Elemente von @liste dereferenziert (@$elemente) in einer Schleife ausgegeben: lesbare Daten, also die eingelesenen Kennzeichen.

--------------

Zur Weiterverarbeitung benötigte ich akz1 und akz2 in je einem Listen-Datensatz: in $element[x] also: "akz1;akz2" usw weil ich anders regieren muss wenn akz1 und akz2 gleiche werte enthalten.

Ich hab also @$elemente in einen string ge-join-t und wieder in eine neue Liste ge-push-t. Jetzt hatte ich die Daten so wie ich sie haben wollte. Diese Liste hab ich widerum zerlegt und die einzelnen Werte bei gleichheit einmal und bei ungleichheit beide je einmal -wieder in eine neue liste ge-push-t.

Mit der Anweisung my %saw; grep !$saw{( split/;/,$_)[0]}++ , @inhalt; entferne ich nun doppelte -> wert Vorkommen und in hash ->name steht nun die anzahl der Vorkommen.

Den Hash widerum lese ich erneut paarweise in eine @liste ein, die ich vor der Ausgabe entweder nach Anzahl Vorkommen oder nach Alphabet ordnen lasse.

Aus der geordneten Liste erstelle ich eine Optionlist.

Dann hab ich mir die ganze puscherei, joinerei und schleiferei angeschaut und mir gedacht, das sollte doch wohl einfacher auch gehen als über 20 Ecken.

Sinn der Ausgabe ~: In der Datenbank befinden sich x Datensätze mit den KFZ-Kennzeichen ABC, x mit DEF usw., die in beiden Rubriken akz1 und akz2 vorkommen. Wenn in der Rubrik akz1 und akz2 allerdings das gleiche Kennzeichen steht, der Datensatz also in nur einer Rubrik gelistet ist, wurde der Datensatz auch nur ein mal gezählt.

Lieber User nun wähle aus welche Kennzeichen-Rubrik Du Dir anschauen willst. Wähle aus ob die Auswahlliste A-Z geordnet werden soll oder nach der Anzahl der Vorkommen 9-0.

----------------

Es läuft: Aber die ganzen Umwege bereiten sogar mir Schmerzen.

Gruss Gustl

[Siechfred]

Um es zu verstehen hab ich $ref stückweise zerlegt und mir die einzelnen Ergebnisse erst mal ausgeben lassen.

Nein, du solltest dir $ref *im Ganzen* ausgeben lassen, dann hättest du gesehen, dass die Referenz in etwa folgende Struktur hat:

array ( array ('GTH', 'EF'),  
        array ('L', 'DD'),  
        array ('HRO', 'HGW')  
      )

Dann kannst du dereferenzieren:

push @deref, @{$ref};

Damit kopierst du die Referenz in ein Array, das genau die gleiche Struktur wie deine Referenz hat. Da du das aber so nicht willst, musst du die Elemente durchgehen, derefernzieren und die inneren Arrays zusätzlich zusammenfügen (dafür gibt es join). Das Ganze verkürzt:

foreach(@{$ref}) {  
  push @deref, join(';', @{$_});  
}

Das Ergebnis sieht wie folgt aus:

@deref: [0] : 'GTH;EF'
        [1] : 'L;DD'
        [2] : 'HRO;HGW'

Und genau das kannst du bereits in deiner SQL-Abfrage mit Hilfe der Stringfunktionen regulieren:

SELECT  
  CONCAT( akz1, ';', akz2 ) AS kennzeichenliste  
FROM  
  tabelle

Dann kannst du dir den ganzen Kram mit Dereferenzieren usw. sparen, da die Ergebnistabelle bereits das ist, was du suchst.

Sinn der Ausgabe ~: In der Datenbank befinden sich x Datensätze mit den KFZ-Kennzeichen ABC, x mit DEF usw., die in beiden Rubriken akz1 und akz2 vorkommen. Wenn in der Rubrik akz1 und akz2 allerdings das gleiche Kennzeichen steht, der Datensatz also in nur einer Rubrik gelistet ist, wurde der Datensatz auch nur ein mal gezählt.

Ich bin mir ziemlich sicher, dass sich auch dies über SQL lösen ließe, da ich aber nicht gerade die MySQL-Leuchte bin, mögen sich andere dazu äußern :)

Siechfred

[Gustl]

Nein, du solltest dir $ref *im Ganzen* ausgeben lassen, dann hättest du gesehen, dass die Referenz in etwa folgende Struktur hat:

array ( array ('GTH', 'EF'),

array ('L', 'DD'),
        array ('HRO', 'HGW')
      )

>   
  
Die Struktur war mir schon klar :) Ich kam nur irgendwie mit der @$-schreibweise nicht zurecht. Das sitzt aber jetzt.  
  

> ~~~perl

foreach(@{$ref}) {  

>   push @deref, join(';', @{$_});  
> }

Das Ergebnis sieht wie folgt aus:

@deref: [0] : 'GTH;EF'
        [1] : 'L;DD'
        [2] : 'HRO;HGW'

Das hatte ich sogar schon aus eigener Kraft gelöst. Schulterklopf mir :)

Und genau das kannst du bereits in deiner SQL-Abfrage mit Hilfe der Stringfunktionen regulieren:

Menno, da ist ne Deutsche 5.1 drauf ? Das ist wohl einer der besten Hinweise heute, da hab ich gar nicht damit gerechnet also auch nicht danach gesucht. Und ich quäl mich ab ...

SELECT

CONCAT( akz1, ';', akz2 ) AS kennzeichenliste
FROM
  tabelle

  
Wo wäre ich nur ohne Euch !  
  
Grüsse Gustl

[Struppi]

Sinn der Ausgabe ~: In der Datenbank befinden sich x Datensätze mit den KFZ-Kennzeichen ABC, x mit DEF usw., die in beiden Rubriken akz1 und akz2 vorkommen. Wenn in der Rubrik akz1 und akz2 allerdings das gleiche Kennzeichen steht, der Datensatz also in nur einer Rubrik gelistet ist, wurde der Datensatz auch nur ein mal gezählt.

irgendwie klingt das anders, als das was du mit deinen Codebeispielen erreichst.

Aber es dürfte ungefähr dem entsprechen, was ich dir gezeigt hatte https://forum.selfhtml.org/?t=146218&m=949574 ohne Umwege.

Struppi.

[Skeeve]

Moin!

Als nächsten Schritt muss ich doppelt vorkommende Strings entfernen und die Vorkommen zählen.

my %saw; grep !$saw{( split/;/,$_)[0]}++ , @inhalt;

Das ist aber sehr unschön!

grep und map sollte man nicht verwenden, wenn man das Ergebnis nachher verwirft. Wenn man es denn unbedingt verwenden will, aber kein Ergebnis benötigt, dann sollte man beim grep auch ein undef oder eine 0 liefern. Zudem kann man dem Split mitteilen, daß beim ersten ; Schluß ist.

Hier mal ein paar Varianten:

  
use Data::Dumper;  
my @inhalt= ( 'a;1;1', 'a;2;2', 'b;1;1', 'b;2;2' );  
  
{ # Deine Version  
 my %saw;  
 grep  !$saw{( split/;/,$_)[0]}++ , @inhalt;  
  
 print Dumper \%saw;  
}  
  
{ # Variante, die kein unnötiges Ergebnis aufbaut  
  # und beim ersten ; aufhört zu splitten  
 my %saw;  
 grep  { ++$saw{( split/;/,$_,2)[0]}; 0; } @inhalt;  
  
 print Dumper \%saw;  
}  
  
{ # Variante ganz ohne unnötiges Zwischenergebnis  
 my %saw;  
 ++$saw{ $_ } foreach (  map { (split /;/,$_,2)[0] } @inhalt );  
  
 print Dumper \%saw;  
}  
  
{ # Oder so, um es vielleicht deutlicher zu machen, was abläuft  
 my %saw;  
 foreach ( @inhalt ) {  
  my ($akz)= split /;/, $_, 2;  
  ++$saw{ $akz };  
 }  
  
 print Dumper \%saw;  
}  
  
{ # und hier eine Variante die aufs Zählen verzichtet.  
  # Praktisch, wenn man nicht an der Anzahl der Vorkommen  
  # interessiert ist  
 my %saw;  
 @saw{ map { (split /;/,$_,2)[0] } @inhalt }= ();  
  
 print Dumper \%saw;  
}  

-- Skeeve

[Struppi]

my %saw; grep !$saw{( split/;/,$_)[0]}++ , @inhalt;

Das ist aber sehr unschön!

wobei ich auch davon überzeugt bin, dass es sowieso überflüssig ist, da erst die Werte aus der DB zusammengepappt werden um sie dann hier wieder zu trennen. Das ganze liesse sich unmittelbar beim einlesen der DB lösen.

Struppi.

[Gustl]

Das ist aber sehr unschön!

Hi Skeeve, soweit steig i da net rin.

Es ist eine hier im Forum erarbeitete Anweisung die ich einfach so verwende wenn ich single-listen haben muss.

Und die ich nebenbei bemerkt nicht in allen Einzelheiten verstehe, ich bin also dafür der falsche Diskussionspartner.

Der Dumper-Print ist jedenfalls, bis auf die letzte immer identisch.

Gruss Gustl

[Skeeve]

Moin!

Es ist eine hier im Forum erarbeitete Anweisung die ich einfach so verwende wenn ich single-listen haben muss.

OMG! Das wurde tatsächlich hier vorgestellt!?

Und die ich nebenbei bemerkt nicht in allen Einzelheiten verstehe, ich bin also dafür der falsche Diskussionspartner.

Dann wähle Dir einfach eine der anderen Varianten, denn

Der Dumper-Print ist jedenfalls, bis auf die letzte immer identisch.

Genau das war das Ziel. Und daß der letzte anders aussieht steht ja auch im Kommentar. Der ist für den Fall, daß kein Zähler gebraucht wird.

-- Skeeve

[迪拉斯]

Hey,

my $ref = [[qw(foo bar)]];  
push my @inhalt, @{$ref->[0]};  

[Gustl]

Guten Morgen. Es ist jetzt 00:20:23:44:17 UTC

Hey,

my $ref = [[qw(foo bar)]];

push my @inhalt, @{$ref->[0]};

  
Hi auch ! Der Versuch:  
  
`my $ref=$selinh->fetchall_arrayref; push my @inhalt, @{$ref->[0]};`{:.language-perl}  
  
liefert nur 2 Datensätze ...  
  
Gruss Gustl

[Siechfred]

my $ref=$selinh->fetchall_arrayref; push my @inhalt, @{$ref->[0]};
liefert nur 2 Datensätze ...

Lasse dir mal via Data::Dumper beides ausgeben: $ref und @inhalt.

Siechfred