Moin!

Ich übe mich, wie schon mal erwähnt, in Perl.

gegeben ein hash

%hash, mit daten

$hash{"bla"} = "Text";
$hash{"blub"} = "Text1";

Das wird mit
print FILE %hash;
in ein File geschrieben.

Wie kann ich das lesen und und wieder in ein(en) hash bringen,
so dass die Zuordnungen Schlüssel|Wert erhalten bleiben, um dann
geziehlt auf einzelne Werte zugreifen zu können?

Danke für Hilfe.
Rolf

Rolf Buenning <r.buenning@gmx.de> wrote:

> gegeben ein hash
>
> %hash, mit daten
>
> $hash{"bla"} = "Text";
> $hash{"blub"} = "Text1";
>
> Das wird mit
> print FILE %hash;
> in ein File geschrieben.

Hast du mal in dieses FILE reingeschaut?
Da steht dann alles hintereinander, das bekommst du nicht mehr (getrennt)
eingelesen!

> Wie kann ich das lesen und und wieder in ein(en) hash bringen,
> so dass die Zuordnungen Schlüssel|Wert erhalten bleiben, um dann
> geziehlt auf einzelne Werte zugreifen zu können?

Wie ueblich bei Perl gibts da viele Moeglichkeiten :-)

zB so:

use Data::Dumper;

(...)

print FILE Data::Dumper->Dump([\%hash],["*hash"]);

Zum Einlesen :

open FILE,'file' or die $!;
local $/;
$_ = <FILE>;
close FILE;
eval $_;

Ich rate aber eher dazu Scalare statt bareword file handles zu verwenden,
also:

open $file,$file or die $!;
local $/;
$_ = <$file>;
close $file;
eval $_;

--
Ullrich Horlacher Server und Virtualisierung
Rechenzentrum TIK
Universitaet Stuttgart E-Mail: horlacher@tik.uni-stuttgart.de
Allmandring 30a Tel: ++49-711-68565868
70569 Stuttgart (Germany) WWW: https://www.tik.uni-stuttgart.de/

On 2024-01-26 11:09, Ulli Horlacher <framstag@rus.uni-stuttgart.de> wrote:
> Rolf Buenning <r.buenning@gmx.de> wrote:
>
>> gegeben ein hash
>>
>> %hash, mit daten
>>
>> $hash{"bla"} = "Text";
>> $hash{"blub"} = "Text1";
>>
>> Das wird mit
>> print FILE %hash;
>> in ein File geschrieben.
>
> Hast du mal in dieses FILE reingeschaut?
> Da steht dann alles hintereinander, das bekommst du nicht mehr (getrennt)
> eingelesen!
>
>
>> Wie kann ich das lesen und und wieder in ein(en) hash bringen,
>> so dass die Zuordnungen Schlüssel|Wert erhalten bleiben, um dann
>> geziehlt auf einzelne Werte zugreifen zu können?
>
> Wie ueblich bei Perl gibts da viele Moeglichkeiten :-)
>
> zB so:
>
> use Data::Dumper;
>
> (...)
>
> print FILE Data::Dumper->Dump([\%hash],["*hash"]);
>
>
> Zum Einlesen :
>
> open FILE,'file' or die $!;
> local $/;
> $_ = <FILE>;
> close FILE;
> eval $_;

Das sollte man aber nur machen, wenn man weiß, was in dem File steht
(keine Trust Boundary zwischen schreiben und lesen).

Das Perl Standard-Modul zum Serialisieren und Deserialisieren von
Datenstrukturen ist Storable.

Ebenso wie die Methode mit Data::Dumper und eval braucht man aber auch
bei Storable wieder ein Perl-Script zum Lesen. Ich empfehle im
Allgemeinen sprachunabhängige Datenformate, wie z.B. JSON, YAML oder
XML. Im Einzelfall muss man sich ansehen, ob ein Datenformat den
Anforderungen entspricht.

hp

Ulli Horlacher <framstag@rus.uni-stuttgart.de> schrieb:
> Rolf Buenning <r.buenning@gmx.de> wrote:
>
> Hast du mal in dieses FILE reingeschaut?
> Da steht dann alles hintereinander, das bekommst du nicht mehr (getrennt)
> eingelesen!

Ja, habe ich, und wohl war, steht alles hintereinander.
>
>
>> Wie kann ich das lesen und und wieder in ein(en) hash bringen,
>> so dass die Zuordnungen Schlüssel|Wert erhalten bleiben, um dann
>> geziehlt auf einzelne Werte zugreifen zu können?
>
> Wie ueblich bei Perl gibts da viele Moeglichkeiten :-)
>
> zB so:
>
> use Data::Dumper;
>
> (...)
>
> print FILE Data::Dumper->Dump([\%hash],["*hash"]);
>
>
> Zum Einlesen :
>
> open FILE,'file' or die $!;
> local $/;
> $_ = <FILE>;
> close FILE;
> eval $_;
>
>
> Ich rate aber eher dazu Scalare statt bareword file handles zu verwenden,
> also:
>
>
> open $file,$file or die $!;
> local $/;
> $_ = <$file>;
> close $file;
> eval $_;
>
Danle, probier ich aus.
Melde mich dann.

Rolf

Rolf Buenning <r.buenning@gmx.de> wrote:
> Ulli Horlacher <framstag@rus.uni-stuttgart.de> schrieb:
>> Rolf Buenning <r.buenning@gmx.de> wrote:
>>
>> Hast du mal in dieses FILE reingeschaut?
>> Da steht dann alles hintereinander, das bekommst du nicht mehr (getrennt)
>> eingelesen!
>
> Ja, habe ich, und wohl war, steht alles hintereinander.

Und wie wolltest du das wieder einlesen, zumindest theoretisch? :-)

Das ist wie ein Puzzle in einen Eimer werfen, dann den Eimer umstuelpen
und hoffen, dass das fertige Puzzle wieder rauskommt.

--
Ullrich Horlacher Server und Virtualisierung
Rechenzentrum TIK
Universitaet Stuttgart E-Mail: horlacher@tik.uni-stuttgart.de
Allmandring 30a Tel: ++49-711-68565868
70569 Stuttgart (Germany) WWW: https://www.tik.uni-stuttgart.de/

Ulli Horlacher <framstag@rus.uni-stuttgart.de> schrieb:
> Rolf Buenning <r.buenning@gmx.de> wrote:
>> Ulli Horlacher <framstag@rus.uni-stuttgart.de> schrieb:
>>> Rolf Buenning <r.buenning@gmx.de> wrote:
>>>
>>> Hast du mal in dieses FILE reingeschaut?
>>> Da steht dann alles hintereinander, das bekommst du nicht mehr (getrennt)
>>> eingelesen!
>>
>> Ja, habe ich, und wohl war, steht alles hintereinander.
>
> Und wie wolltest du das wieder einlesen, zumindest theoretisch? :-)
>
> Das ist wie ein Puzzle in einen Eimer werfen, dann den Eimer umstuelpen
> und hoffen, dass das fertige Puzzle wieder rauskommt.
>

Darüber wollte ich nachdenken, wenn das bis dashin geklappt hat.

Peter J. Holzer <hjp-usenet4@hjp.at> schrieb:
> On 2024-01-26 11:09, Ulli Horlacher <framstag@rus.uni-stuttgart.de> wrote:
>> Rolf Buenning <r.buenning@gmx.de> wrote:
>>
>>> gegeben ein hash
>>>
>> eval $_;
>
> Das sollte man aber nur machen, wenn man weiß, was in dem File steht
> (keine Trust Boundary zwischen schreiben und lesen).
>
> bei Storable wieder ein Perl-Script zum Lesen. Ich empfehle im
> Allgemeinen sprachunabhängige Datenformate, wie z.B. JSON, YAML oder
> XML. Im Einzelfall muss man sich ansehen, ob ein Datenformat den
> Anforderungen entspricht.

Ich weiss natürlich, was in dem File steht.
Ich denke z.Zt. über andere Datenformate nach.
Mit Hashes erscheint mir das doch recht kompliziert,
wenn ich an meine beschränkten Perl-Kenntnisse denke.

S.auch main anderes Posting.

Rolf

Ulli Horlacher <framstag@rus.uni-stuttgart.de> schrieb:
> Rolf Buenning <r.buenning@gmx.de> wrote:
>
>> gegeben ein hash
>>
>> %hash, mit daten
>>
>> Das wird mit
>> print FILE %hash;
>> in ein File geschrieben.
>
>
>
>> Wie kann ich das lesen und und wieder in ein(en) hash bringen,
>> so dass die Zuordnungen Schlüssel|Wert erhalten bleiben, um dann
>> geziehlt auf einzelne Werte zugreifen zu können?
>
> Wie ueblich bei Perl gibts da viele Moeglichkeiten :-)
>
> zB so:
>
> use Data::Dumper;
>
>

Das funktioniert (natürlich!).
Aber ich verstehe den Code nicht wirklich, dazu sind meine
Perl-Kenntnisse doch zu sehr begrenzt.
Das scheitert schon an der local $/ Deklaration, wenn
das Lesen in eine sub ausgelagert wird.

Ich denke z.Zt. über ein anderes Datenformat nach,
das ich mit meinen doch begrenzten Perl-Kenntnissen besser
behandeln kann.

Rolf

Rolf Buenning <r.buenning@gmx.de> wrote:

>> use Data::Dumper;
>
> Das funktioniert (natürlich!).
> Aber ich verstehe den Code nicht wirklich, dazu sind meine
> Perl-Kenntnisse doch zu sehr begrenzt.

Dazulernen ist nicht verboten! :-)

> Das scheitert schon an der local $/ Deklaration, wenn
> das Lesen in eine sub ausgelagert wird.

Das besagt, dass innerhalb des Programmblocks ein read bis EOF statt bis
EOL erfolgt. Es wird also alles in einem Rutsch eingelesen.

> Ich denke z.Zt. über ein anderes Datenformat nach,
> das ich mit meinen doch begrenzten Perl-Kenntnissen besser
> behandeln kann.

Hashes sind eine primitive native Datenstruktur. Viel einfacher gehts kaum.
Wenn dir das zu kompliziert ist und du nichts lernen willst, solltest du
deine Programmieraufgaben deligieren :-)

--
Ullrich Horlacher Server und Virtualisierung
Rechenzentrum TIK
Universitaet Stuttgart E-Mail: horlacher@tik.uni-stuttgart.de
Allmandring 30a Tel: ++49-711-68565868
70569 Stuttgart (Germany) WWW: https://www.tik.uni-stuttgart.de/

Rolf Buenning <r.buenning@gmx.de> wrote:

> Ich denke z.Zt. über ein anderes Datenformat nach,
> das ich mit meinen doch begrenzten Perl-Kenntnissen besser
> behandeln kann.

Du koenntest auch dein hash an eine Berkeley DB binden, dann musst du erst
gar nicht explizit lesen oder schreiben.

perldoc DB_File

Bedenke aber dass jede hash-Element Zuweisung auch ein disk write bewirkt.

--
Ullrich Horlacher Server und Virtualisierung
Rechenzentrum TIK
Universitaet Stuttgart E-Mail: horlacher@tik.uni-stuttgart.de
Allmandring 30a Tel: ++49-711-68565868
70569 Stuttgart (Germany) WWW: https://www.tik.uni-stuttgart.de/

On 2024-01-27 12:38, Rolf Buenning <r.buenning@gmx.de> wrote:
> Peter J. Holzer <hjp-usenet4@hjp.at> schrieb:
>> On 2024-01-26 11:09, Ulli Horlacher <framstag@rus.uni-stuttgart.de> wrote:
>>> Rolf Buenning <r.buenning@gmx.de> wrote:
>>>
>>>> gegeben ein hash
>>>>
>>> eval $_;
>>
>> Das sollte man aber nur machen, wenn man weiß, was in dem File steht
>> (keine Trust Boundary zwischen schreiben und lesen).
>>
>> bei Storable wieder ein Perl-Script zum Lesen. Ich empfehle im
>> Allgemeinen sprachunabhängige Datenformate, wie z.B. JSON, YAML oder
>> XML. Im Einzelfall muss man sich ansehen, ob ein Datenformat den
>> Anforderungen entspricht.
>
> Ich weiss natürlich, was in dem File steht.
> Ich denke z.Zt. über andere Datenformate nach.
> Mit Hashes erscheint mir das doch recht kompliziert,
> wenn ich an meine beschränkten Perl-Kenntnisse denke.

Im Gegenteil, das ist ganz einfach, weil Du jeweils nur eine einzige
Funktion aufrufen musst, die das garantiert richtig macht und Du Dir
keine Gedanken über Sonderfälle machen musst.

So sieht das mit Storable aus:

---[write_storable]-----------------------------
#!/usr/bin/perl
use v5.24;
use warnings;

use Storable;

my %hash = (
a => 42,
b => "a string",
c => ['a', 'list'],
);

store \%hash, 'storable-test.data';
------------------------------------------------

---[read_storable]------------------------------
#!/usr/bin/perl
use v5.24;
use warnings;

use Storable;
use Data::Dumper;

my $hashref = retrieve('storable-test.data');
print Dumper $hashref;
------------------------------------------------

Also jeweils eine Zeile.

Und so mit JSON:

---[write_json]---------------------------------
#!/usr/bin/perl
use v5.24;
use warnings;

use JSON;

my %hash = (
a => 42,
b => "a string",
c => ['a', 'list'],
);

open my $fh, '>', 'json-test.json';
print $fh encode_json(\%hash)
------------------------------------------------

---[read_json]----------------------------------
#!/usr/bin/perl
use v5.24;
use warnings;

use JSON;;
use Data::Dumper;

open my $fh, '<', 'json-test.json';
local $/;
my $hashref = decode_json(<$fh>);

print Dumper $hashref;
------------------------------------------------

Hier sind es zwei bis drei Zeilen, weil das JSON-Modul keine Funktion
zur Verfügung stellt, die direkt auf Files arbeitet. Das muss man also
selbst machen. Aber auch nicht wesentlich komplizierter.

hp

On 2024-01-27 12:43, Rolf Buenning <r.buenning@gmx.de> wrote:
> Ulli Horlacher <framstag@rus.uni-stuttgart.de> schrieb:
[Daten in ein File schreiben und wieder lesen]
>
> Das funktioniert (natürlich!).
> Aber ich verstehe den Code nicht wirklich, dazu sind meine
> Perl-Kenntnisse doch zu sehr begrenzt.
> Das scheitert schon an der local $/ Deklaration, wenn
> das Lesen in eine sub ausgelagert wird.

$/ ist eine der vielen magischen Variablen, die von Perl vordefiniert
und verwendet werden (da merkt man, dass Perl u.a. von der Unix-Shell
inspiriert war). Es definiert das Zeilenende beim Lesen des Files. Wenn
es auf undef gesetzt wird, gibt es kein Zeilenende und <FH> liest das
ganze File auf einmal. Das ist ein praktischer Trick. Aber nicht
unbedingt notwendig, man könnte das File auch zeilenweise einlesen und
zusammenstückeln. local ist in längeren Programmen wichtig, weil man $/
normalerweise nicht dauerhaft umsetzen will, sondern nur, während man
dieses File liest. Wenn man das also in einer Funktion (oder sogar einem
Block) verwendet, ist nachher wieder alles so, wie es vorher war.

hp

Peter J. Holzer <hjp-usenet4@hjp.at> schrieb:
> On 2024-01-27 12:38, Rolf Buenning <r.buenning@gmx.de> wrote:
>> Peter J. Holzer <hjp-usenet4@hjp.at> schrieb:

>> Mit Hashes erscheint mir das doch recht kompliziert,
>> wenn ich an meine beschränkten Perl-Kenntnisse denke.
>
> Im Gegenteil, das ist ganz einfach, weil Du jeweils nur eine einzige
> Funktion aufrufen musst, die das garantiert richtig macht und Du Dir
> keine Gedanken über Sonderfälle machen musst.
>
> So sieht das mit Storable aus:
>
> Und so mit JSON:
>

Sorry, dass es etwas 'länglich' gedauert hat, bis ich hierauf reagiert
habe.

Einerseits konnte ich aus persöhnlichen Gründen nicht, andererseits
musste ich diese Dinge natürlich ausprobieren.

Das Projekt soll eine Terminverwaltung werden, mit Erinnerung
bzw. Anzeige fälliger Termine nach Systemstart.

Nicht, dass ich sowas bräuchte, habe ich auf dem Handy schon.
Ich mache das nur, um zu lernen und aus Spass an der Freude.
(und womit kann man als Rentner besser seine Zeit verbringen).

Das bedeutet auch, dass ich mehrere 'Termine' speichern, ändern
auch wieder lesen, anzeigen muss.
Und das habe ich mit den von Euch/Dir gezeigten Möglichkeiten
nicht hinbekommen.

Ich mache das jetzt alles selber und speichere jeden Termin
in einem String, wobei die einzelnen 'Felder' mit "|"
getrennt werden, bin aber noch lange nicht fertig,
z.B. fehlt noch die Prüfung auf Korrektheit des
Datums, habe Date::Calc schon eingebunden.

Also nochmal Danke.

Rolf

Ich bedanke mich bei Allen, die mir bisher geholfen haben.

D.h. ich

Rolf Buenning <r.buenning@gmx.de> schrieb:
> Peter J. Holzer <hjp-usenet4@hjp.at> schrieb:
>> On 2024-01-27 12:38, Rolf Buenning <r.buenning@gmx.de> wrote:
>>> Peter J. Holzer <hjp-usenet4@hjp.at> schrieb:
>
>
> Also nochmal Danke.
>
> Rolf
>
>
> Ich bedanke mich bei Allen, die mir bisher geholfen haben.
>
>
>
> D.h. ich
Grrr.
Das passiert, wenn man unkonzentriert ist.

On 2024-02-12 09:27, Rolf Buenning <r.buenning@gmx.de> wrote:
> Peter J. Holzer <hjp-usenet4@hjp.at> schrieb:
>> On 2024-01-27 12:38, Rolf Buenning <r.buenning@gmx.de> wrote:
>>> Peter J. Holzer <hjp-usenet4@hjp.at> schrieb:
>>> Mit Hashes erscheint mir das doch recht kompliziert,
>>> wenn ich an meine beschränkten Perl-Kenntnisse denke.
>>
>> Im Gegenteil, das ist ganz einfach, weil Du jeweils nur eine einzige
>> Funktion aufrufen musst, die das garantiert richtig macht und Du Dir
>> keine Gedanken über Sonderfälle machen musst.
>>
>> So sieht das mit Storable aus:
>>
>> Und so mit JSON:
[...]
> Das Projekt soll eine Terminverwaltung werden, mit Erinnerung
> bzw. Anzeige fälliger Termine nach Systemstart.
[...]
> Und das habe ich mit den von Euch/Dir gezeigten Möglichkeiten
> nicht hinbekommen.

Ein Stolperstein, auf den ich wahrscheinlich explizit hätte hinweisen
sollen, ist der Unterschied zwischen einem Hash und einer Hash-Referenz.
Diese Funktionen erwarten und liefern Hash-Referenzen, nicht Hashes!

Generell gehört das Typsystem IMHO zu den grundlegenden Konzepten einer
Programmiersprache, die man wirklich verstehen muss, um diese Sprache
sinnvoll verwenden zu können.

Bei Perl gehört da dazu:

* Was sind Skalare, Arrays bzw. Listen und Hashes?
* Was bedeuten die Sigils ($, @, %, &) wirklich?
* Was sind Referenzen und wie verwendet man sie?

> Ich mache das jetzt alles selber und speichere jeden Termin
> in einem String, wobei die einzelnen 'Felder' mit "|"
> getrennt werden,

Das ist zum Lernen auf jeden Fall gut. Erstens weil eine funktionierende
Lösung ein Erfolgserlebnis bringt, zweitens weil man beim Selber-
programmieren mehr lernt als beim Aufrufen einer Funktion, die schon
alles macht.

Allerdings ist das Verstehen und Debuggen von existierendem Code auch
ein wichtiger Skill, ich würde also dazu raten, dass Du Dir irgendwann
später (wenn Du mit Deiner Terminverwaltung fertig bist) unsere
Beispiele noch einmal vornimmst und versuchst, herauszufinden, warum die
nicht das gemacht haben, was Du erwartet hast.

hp

Peter J. Holzer <hjp-usenet4@hjp.at> schrieb:
> On 2024-02-12 09:27, Rolf Buenning <r.buenning@gmx.de> wrote:

>> Das Projekt soll eine Terminverwaltung werden, mit Erinnerung
>> bzw. Anzeige fälliger Termine nach Systemstart.
> [...]
>> Und das habe ich mit den von Euch/Dir gezeigten Möglichkeiten
>> nicht hinbekommen.
>
> Ein Stolperstein, auf den ich wahrscheinlich explizit hätte hinweisen
> sollen, ist der Unterschied zwischen einem Hash und einer Hash-Referenz.
> Diese Funktionen erwarten und liefern Hash-Referenzen, nicht Hashes!
>
> Generell gehört das Typsystem IMHO zu den grundlegenden Konzepten einer
> Programmiersprache, die man wirklich verstehen muss, um diese Sprache
> sinnvoll verwenden zu können.
>
> Bei Perl gehört da dazu:
>
> * Was sind Skalare, Arrays bzw. Listen und Hashes?
> * Was bedeuten die Sigils ($, @, %, &) wirklich?
> * Was sind Referenzen und wie verwendet man sie?
>
>
>> Ich mache das jetzt alles selber und speichere jeden Termin
>> in einem String, wobei die einzelnen 'Felder' mit "|"
>> getrennt werden,
>
> Das ist zum Lernen auf jeden Fall gut. Erstens weil eine funktionierende
> Lösung ein Erfolgserlebnis bringt, zweitens weil man beim Selber-
> programmieren mehr lernt als beim Aufrufen einer Funktion, die schon
> alles macht.
>
> Allerdings ist das Verstehen und Debuggen von existierendem Code auch
> ein wichtiger Skill, ich würde also dazu raten, dass Du Dir irgendwann
> später (wenn Du mit Deiner Terminverwaltung fertig bist) unsere
> Beispiele noch einmal vornimmst und versuchst, herauszufinden, warum die
> nicht das gemacht haben, was Du erwartet hast.
>

OK, notiert, behalte ich im Gedächtnis.

Rolf

Von Rentner zu Renter,

https://metacpan.org/pod/Tie::iCal

mfg, el

On 12/02/2024 11:27, Rolf Buenning wrote:
[...]
> Das Projekt soll eine Terminverwaltung werden, mit Erinnerung
> bzw. Anzeige fälliger Termine nach Systemstart.
>
> Nicht, dass ich sowas bräuchte, habe ich auf dem Handy schon.
> Ich mache das nur, um zu lernen und aus Spass an der Freude.
> (und womit kann man als Rentner besser seine Zeit verbringen).
>
> Das bedeutet auch, dass ich mehrere 'Termine' speichern, ändern
> auch wieder lesen, anzeigen muss.
> Und das habe ich mit den von Euch/Dir gezeigten Möglichkeiten
> nicht hinbekommen.
[...]

Eberhard W Lisse <nospam@lisse.NA> schrieb:
> Von Rentner zu Renter,
>
> https://metacpan.org/pod/Tie::iCal

Ahh, interessant, werde ich mir ansehen, Danke.
Rolf