Umfangreiche Hash Referenz mit Regex und Code kopieren (gelöst) (Fragen zu Perl-Modulen) - Perl-Community.de

Start · Board · Anwendungen/Programme/Skripte in Perl · Fragen zu Perl-Modulen

2024-11-22 13:22:18
Europe/Berlin
Einloggen (Registrieren)
- Einstellungen
- Statistics
Jemand zu Hause?
0 Benutzer online
2 Gäste

[thread]19998[/thread]

submit to reddit

Umfangreiche Hash Referenz mit Regex und Code kopieren [gelöst]

[gelöst]

Tags: perl5 Ähnliche Threads

Leser: 18

Articles: hide open all | hide show old branches

+21 replies
bianca

2016-02-26 09:38

User since
2009-09-13
7016 Artikel
BenutzerIn

Guten Morgen!
Mit Storable kann man keine Code oder Regexp Teile kopieren.

Womit kann man denn in Perl >= 5.14 umfangreiche Hash Referenzen kopieren?
10 print "Hallo"
20 goto 10
- +5 replies
- GwenDragon
  
  2016-02-26 10:39
  
  User since
  2005-01-17
  14748 Artikel
  Admin1
  
  Clone oder Clone::PP kann tiefe Strukturen kopieren.
  
  Aber was möchtest du denn genau machen? Wofür brauchst du da Storable? Hast du ein Beispielschnippsel?
  die Drachin Gwen
  
  Meine Perl-Artikel · perldev – verschiedene Perl-Versionen unter Windows starten
  - +3 replies
  - bianca
    
    2016-02-26 10:49
    User since
    2009-09-13
    7016 Artikel
    BenutzerIn
    
    Bei clone sind aber auch nur "normale" Daten angegeben, keine Regexe und Codes.
    
    Ich hab ein internes großes Konfig Hash, das auch Regexps und Code enthält. Das muss ich kopieren, um Unterprogramme mit einer manipulierten Umgebung aufrufen zu können.
    
    Code (perl): (dl )
    
    1 2 3 4 5 6 7 8 9 10
    
    my $alt = { foo => 'bar', code => sub{ my ($t) = @_; say $t; }, }; require Storable; my $neu = Storable::dclone($alt); say $neu->{code}->('Hallo Welt');
    
    10 print "Hallo"
    20 goto 10
    - +2 replies
    - Linuxer
      
      2016-02-26 11:48
      
      User since
      2006-01-27
      3890 Artikel
      HausmeisterIn
      
      2016-02-26T09:49:29 bianca
      Bei clone sind aber auch nur "normale" Daten angegeben, keine Regexe und Codes.
      
      Wo steht, dass clone() auf normale Daten beschränkt ist?
      Wo werden Regex und Code explizit ausgeschlossen?
      Hast Du es wenigstens mal ausprobiert und überprüft?
      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!
      - bianca
        
        2016-02-26 12:20
        
        User since
        2009-09-13
        7016 Artikel
        BenutzerIn
        
        Quote
        This module provides a clone() method which makes recursive copies of nested hash, array, scalar and reference types, including tied variables and objects.
        
        Das schließt für mich Regexe und Code aus.
        Aber ich versuche es trotzdem.
        10 print "Hallo"
        20 goto 10
  - bianca
    
    2016-02-28 09:27
    User since
    2009-09-13
    7016 Artikel
    BenutzerIn
    
    Ja, Clone ist tatsächlich meine Lösung.
    Danke GewenDragon und die anderen Antwortenden weiter unten!
    
    Code (perl): (dl )
    
    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
    
    #!/usr/bin/perl use strict; use warnings; use 5.010; my $alt = { foo => 'bar', code => sub{ say $_[0]; }, }; # kopieren use Clone 0.37; my $neu = Clone::clone($alt); # die Kopie ändern $neu->{code} = sub{ say "Und jetzt: ".$_[0]; }; $neu->{foo} = 'bar2'; $neu->{code}->('Hallo Welt neu'); # schauen ob das Original unverändert geblieben ist $alt->{code}->('Hallo Welt alt'); say $alt->{foo};
    
    Quote
    Und jetzt: Hallo Welt alt
    Hallo Welt neu
    
    Editiert von bianca: use 5.010; ergänzt
    Last edited: 2016-02-28 09:31:13 +0100 (CET)
    10 print "Hallo"
    20 goto 10
- +10 replies
- Gast janus_reg
  
  2016-02-26 13:37
  Code (perl): (dl )
  
  $eferenzkopie = $referenz;
  
  Last edited: 2016-02-26 15:00:59 +0100 (CET)
  - +3 replies
  - Gast pq_unterwegs
    
    2016-02-26 16:46
    
    es ging um deep copy...
    Last edited: 2016-02-26 17:08:27 +0100 (CET)
    - +2 replies
    - Gast janus_reg
      
      2016-02-26 17:43
      
      Guest pq_unterwegs
      es ging um deep copy...
      
      geh doch:
      
      Code (perl): (dl )
      
      1 2 3 4 5 6 7 8 9 10
      
      my $alt = { foo => 'bar', code => sub{ my ($t) = @_; print $t; }, }; my $neu = $alt; $neu->{code}->('Hallo Welt');
      - clms
        
        2016-02-26 18:19
        
        User since
        2010-08-29
        373 Artikel
        BenutzerIn
        
        Dein Beispiel ist KEINE deep copy. Du kopierst nur die Adresse des anonymen Hashs, nicht die komplette hierarchische Datenstruktur. Es wird also für 'code' die anonyme sub nicht dupliziert.
        
        Wenn Du es nicht glaubst, häng mal folgenden Code an Dein Beispiel an
        
        Code (perl): (dl )
        
        1 2
        
        $alt->{foo} = 123; print $neu->{foo}."\n";
  - +6 replies
  - bianca
    
    2016-02-26 18:31
    
    User since
    2009-09-13
    7016 Artikel
    BenutzerIn
    
    wie clms schon schrieb brauche ich eine Kopie und nicht eine Referenz.
    10 print "Hallo"
    20 goto 10
    - +4 replies
    - FIFO
      
      2016-02-26 18:57
      
      User since
      2005-06-01
      469 Artikel
      BenutzerIn
      
      Naja, wie schon gesagt: use Clone:
      
      ohne (Referenzkopie):
      
      Code (perl): (dl )
      
      1 2 3 4 5 6 7 8
      
      my $alt = { code => sub{ printf "alt %s\n", shift } }; my $neu = $alt; $alt->{code} = sub { printf "neu %s\n", shift }; $neu->{code}->('Hallo Welt'); # "neu Hallo Welt"
      
      mit (deep copy):
      
      Code (perl): (dl )
      
      1 2 3 4 5 6 7 8 9 10 11
      
      use Clone "clone"; my $alt = { code => sub{ printf "alt %s\n", shift } }; # my $neu = $alt; my $neu = clone $alt; $alt->{code} = sub { printf "neu %s\n", shift }; $neu->{code}->('Hallo Welt'); # "alt Hallo Welt"
      
      Everyone knows that debugging is twice as hard as writing a program in the first place. So if you're as clever as you can be when you write it, how will you ever debug it? -- Brian Kernighan: "The Elements of Programming Style"
      - +3 replies
      - clms
        
        2016-02-26 23:02
        
        User since
        2010-08-29
        373 Artikel
        BenutzerIn
        
        Bist Du Dir sicher, dass mit clone auch der Code kopiert wurde? Oder nur die Coderef? An Deinem deep-copy-Beispiel kann man das nicht unterscheiden.
        
        Hier ist ein Code-Beispiel, wie man es herausbekommt:
        
        Code (perl): (dl )
        
        1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
        
        use Clone 'clone'; my $alt = { array => [1,2], code => sub{ printf "alt %s\n", shift } }; my $neu = clone $alt; if ($neu->{array} eq $alt->{array}) { say "Das Array wurde nicht kopiert"; } else { say "Das Array wurde kopiert"; } if ($neu->{code} eq $alt->{code}) { say "Die Funktion wurde nicht kopiert"; } else { say "Die Funktion wurde kopiert"; }
        
        Danach wurde bei mir nur das Array aber nicht der Code dupliziert.
        
        Damit kommen wir zur nächsten Frage:
        Warum soll der Code kopiert werden?
        Im vorliegenden Beispiel is es völlig egal, ob die sub kopiert wird oder nicht. Eine 1:1 Kopie der Funktion würde genau das Gleiche machen wie die Originalfunktion. Es ist also egal, ob das Original oder eine Kopie referenziert wird.
        
        Allerdings könnte sich ein Unterschied ergeben, wenn die Funktion state verwendet, z.B. mit sub {state $i; ++$i}
        Da zeigt sich beim Ausprobieren, dass $alt und $neu keine getrennten States verwenden.
        
        +2 replies
        
        pq
        
        2016-02-27 01:18
        
        User since
        2003-08-04
        12208 Artikel
        Admin1
        
        pack mal ein
        $neu->{code} = sub { say "neu" };
        nach das clone und guck, was sich ändert =)
        
        interessanterweise wird das im unterschied zu arrays erst wirklich kopiert, wenns verändert wird. copy-on-write
        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: Wie frage ich & perlintro brian's Leitfaden für jedes Perl-Problem
        
        clms
        
        2016-03-05 16:42
        
        User since
        2010-08-29
        373 Artikel
        BenutzerIn
        
        2016-02-27T00:18:14 pq
        pack mal ein
        $neu->{code} = sub { say "neu" };
        nach das clone und guck, was sich ändert =)
        
        interessanterweise wird das im unterschied zu arrays erst wirklich kopiert, wenns verändert wird. copy-on-write
        
        Ich kann da kein Copy-on-write erkennen.
        
        clone kopiert alle ineinandergeschachtelten Hashes, Arrays und Scalars incl. der Referenzen auf ausführbare Funktionen, aber nicht die ausführbaren Funktionen selbst. Deshalb haben $alt->{code} und $neu->{code} zunächst den gleiche Wert - sie verweisen auf die gleiche Funktion.
        Mit $neu->{code} = sub { say "neu" }; wird eine komplett neue Funktion angelegt und eine Referenz darauf in $neu->{code} gespeichert. Die alte Funktion wird dabei nicht kopiert. Genauso wenig wird der Hash $neu oder der Key code kopiert (das wurde schon mit clone() gemacht).
        
        Aber wie schon geschrieben, ob die Original-Funktion oder eine Kopie der selben verwendet wird, macht nur dann einen Unterschied wenn state-Variablen o.ä. verwendet werden.
        
        Hier ein Beispiel, wo man etwas besser sehen kann, was passiert:
        
        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
        
        use v5.10; use Clone 'clone'; my $alt = { array => [1,2], code => sub{state $i; return ++$i } }; my $neu = clone $alt; if ($neu->{array} eq $alt->{array}) { say "Das Array wurde nicht kopiert"; } else { say "Das Array wurde kopiert"; } if ($neu->{code} eq $alt->{code}) { say "Die Funktion wurde nicht kopiert"; } else { say "Die Funktion wurde kopiert"; } say "alt1: ".($alt->{code}->()); # alt1: 1 say "alt2: ".($alt->{code}->()); # alt2: 2 say "neu1: ".($neu->{code}->()); # neu1: 3 - state von "alt" wird weiter inkrementiert, weil es die gleiche Funktion ist say "neu2: ".($neu->{code}->()); # neu1: 4 $neu->{code} = sub{state $i; return ++$i }; say "neu1-neu: ".($neu->{code}->()); # neu1-neu: 1 - jetzt ist es eine neue state-Variable say "neu2-neu: ".($neu->{code}->()); # neu2-neu: 2 if ($neu->{code} eq $alt->{code}) { say "Die Funktion ist noch die gleiche"; } else { say "Die Funktion ist eine andere"; }
    - Gast janus_reg
      
      2016-02-27 04:58
      
      Wenn Du eine Kopie haben willst musst Du dereferenzieren.
      
      Code (perl): (dl )
      
      $coderef = sub {};
      
      jedoch erzeugt eine CODE-Referenz was nicht rückgängig gemacht werden kann.
      
      MfG
      Last edited: 2016-02-27 09:24:12 +0100 (CET)
- +5 replies
- barney
  
  2024-02-02 10:44
  
  User since
  2008-08-31
  165 Artikel
  BenutzerIn
  
  Diese Diskussion hat vor sieben Jahren stattgefunden. Die Tendenz ging in Richtung Clone und nicht zu `dclone()` von Storable. Hat sich in der Zwischenzeit etwas geändert? Ich frage weil ich eventuell an https://github.com/RotherOSS/otobo/blob/318271c603... herumschrauben will.
  - rosti
    
    2024-02-02 15:00
    
    User since
    2011-03-19
    3472 Artikel
    BenutzerIn
    
    Leider sind Storable-Sequenzen nur mit Storable lesbar. Also nur mit Perl.
    
    MFG
  - Linuxer
    
    2024-02-02 15:32
    
    User since
    2006-01-27
    3890 Artikel
    HausmeisterIn
    
    Nur selten hatte ich in der Vergangenheit Storable::dclone() verwendet. Clone::clone() noch gar nicht, wenn ich mich korrekt erinnere.
    
    Welches nun besser ist, vermag ich mangels Erfahrung nicht beurteilen.
    Ich erinnere mich auch an keine großen Diskussionen, welches von den beiden neuerdings bevorzugt würde.
    
    Clone's perldoc sagt selber:
    
    perldoc Clone
    
    SEE ALSO
    Storable's "dclone()" is a flexible solution for cloning variables, albeit slower for average-sized data structures. Simple and naive benchmarks show that Clone is faster for data structures with 3 or fewer levels, while "dclone()" can be faster for structures 4 or more levels deep.
    
    Während Storable's perldoc sagt:
    
    perldoc Storable
    There is a Clone module available on CPAN which implements deep cloning natively, i.e. without freezing to memory and thawing the result. It is aimed to replace Storable's dclone() some day. However, it does not currently support Storable hooks to redefine the way deep cloning is performed.
    
    Ich würde derzeit zu Storable::dclone() tendieren, weil das seit Perl 5.7.3 im Core enthalten ist und Clone wohl noch nicht.
    
    Der Rest wäre halt selber austesten, was einem vom Verhalten und Performance besser gefällt.
    
    Ziemlich alte Beiträge deuten auf mögliche Probleme hin: https://duckduckgo.com/?q=site%3Aperlmonks.org+sto...
    
    Ob diese Probleme so heute noch relevant sind, weiß ich nicht.
    
    Ich denke, ein Austesten der Varianten wirst Du kaum vermeiden könenn.
    Erkenntnisse aus den Tests wären hier willkommen ;-)
    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!
  - +2 replies
  - haj
    
    2024-02-02 18:01
    
    User since
    2015-01-07
    555 Artikel
    BenutzerIn
    
    Das Argument "im Core enthalten" hat Linuxer schon gebracht, das spricht für Storable.
    
    Für das Kleingedruckte kommt es darauf an, was in der Perl data structure drin sein kann. Wenn es nur Zahlen, Zeichenketten und weitere Referenzen auf Hashes und Arrays sind, gibt es keine Probleme. Auf unterschiedlich unterhaltsame Art und Weise kann man scheitern, wenn einer der Werte blessed ist.
    
    Storable ist ja vor allem für Serialisierung gedacht und geht beim Klonen über einen Freeze/Thaw-Zyklus. Es ist etwas "defensiver", was in den Daten drin sein darf, weil es unterstützen will, dass die serialisierte Daten auch mit einer anderen Perl-Version wieder interpretiert werden können. Deswegen verweigert Storable beispielsweise Code-Referenzen, obwohl sich das Problem "andere Perl-Version" beim Klonen gar nicht stellt.
    
    Objekte, bei denen ein "generisches" Klonen problematisch ist, sind solche mit XS-Komponenten (oft als Skalar-Referenzen implementiert), die ihre Daten in einer C-Struktur an den "Magic"-Pointer der Variablen dranhängen.
    
    Die neuen Objekte mit use feature 'class' lassen sich noch gar nicht klonen. Wenn man sich diesen neuen Objekten mit Feature::Compat::Class annähert, dann funktioniert das Klonen... bis einschließlich Perl 5.36, denn bis dahin wird mit Object::Pad gearbeitet.
    - barney
      
      2024-02-03 11:11
      
      User since
      2008-08-31
      165 Artikel
      BenutzerIn
      
      Danke für die Einschätzungen. Mein Fazit ist dass ich es in OTOBO bei Storable::dclone belasse. Die Vorteile von Clone sind jetzt nicht so hervorstechend und es besteht ein Restrisiko dass es nach einer Umstellung dann doch irgendwo hakt.

View all threads created 2016-02-26 09:38.