1
2
3
my %tmp_io = %$io;
$tmp_io{links}{refer} = 4;# < Zeile 649
say "test: ".join('/',keys %{$io->{links}{refer}});# < Zeile 650
QuoteCan't use string ("4") as a HASH ref while "strict refs" in use at sub_iteriere_verzeichnis.pl line 650.
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
#!/usr/bin/perl use strict; use warnings; use Fcntl qw(:DEFAULT :flock); use Date::Calc; use Data::Dumper; local $Data::Dumper::Purity = 1; local $Data::Dumper::Useqq = 1; local $Data::Dumper::Deparse = 1; local $Data::Dumper::Sortkeys = sub { my ($hash) = @_; return [(sort {lc $a cmp lc $b} keys %$hash)]; }; use 5.010; my %code = ( testsub => sub{ my ($coderef,$irgendwasref,$io) = @_; say "zu Beginn: ".Dumper($io); my %tmp_io = %$io; say "innen vorher : ".Dumper($io); $tmp_io{verkn} = $io->{verkn}{unterschluessel}; say "innen nachher: ".Dumper($io); say "Kopie : ".Dumper(\%tmp_io); }, ); my %irgendwas = (schluessel => {unterschluessel => {unterunter => 7}}); my %start = ( foo => 2, verkn => $irgendwas{schluessel}, ); say "außen vorher : ".Dumper(\%start); $code{testsub}->(\%code,\%irgendwas,\%start); say "außen nachher: ".Dumper(\%start);
2022-02-06T08:40:53 biancaKann das Problem damit zu tun haben, dass ein Hashkey eine Referenz auf ein anderes Hash ist?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
use 5.020; use strict; use warnings; my %deep = ( a => { aa => { aaa => 1, aab => 2, }, ab => 3, }, b => 4 ); use Data::Dumper; my $VAR1; # sonst beisst's den eval wegen use strict; my %ddclone = %{ eval Dumper(\%deep) }; use Storable qw(dclone); my %stclone = %{dclone \%deep};
2022-02-06T11:45:58 haj$tmp_io{links} ist eine Referenz. Wenn Du also auch mit my %tmp_io = %$io; eine flache Kopie erstellst, dann wird diese Referenz kopiert und zeigt in %tmp_io auf den gleichen Hash. Und wenn Du dann in diesem Hash den Wert des Schlüssels refer änderst, dann änderst Du ihn auch in $io!
2022-02-06T17:25:17 hlubenowmit "Data::Dumper". Dann hätte man wahrscheinlich gesehen, das in den Daten was geändert wurde (indem was über die Referenz darauf geändert wurde), und daß man also eine "deep copy" bräuchte.
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
#! /usr/bin/env perl use strict; use warnings; use 5.020; use Data::Dumper; use Storable qw( dclone ); sub _dump { my ( $name, $object ) = @_; say Data::Dumper->new( [ $object ], [ "*$name" ], )->Sortkeys(1) ->Useqq(1) ->Dump(); } my $original = { sub1 => { sub2 => { foo => 'bar' }, }, }; my $tiefe_kopie = dclone($original); my $einfache_kopie = {}; %$einfache_kopie = %$original; $tiefe_kopie->{sub1}{sub2}{foo} = "neu"; say "# Vergleich nach Änderung Tiefe Kopie"; _dump( 'Original' => $original ); _dump( 'Tiefe_Kopie' => $tiefe_kopie ); $einfache_kopie->{sub1}{sub2}{foo} = "hier stand mal bar"; say "# Vergleich nach Änderung einfache Kopie"; _dump( 'Original' => $original ); _dump( 'Einfache_Kopie' => $einfache_kopie );
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
# Vergleich nach Änderung Tiefe Kopie
%Original = (
"sub1" => {
"sub2" => {
"foo" => "bar"
}
}
);
%Tiefe_Kopie = (
"sub1" => {
"sub2" => {
"foo" => "neu"
}
}
);
# Vergleich nach Änderung einfache Kopie
%Original = (
"sub1" => {
"sub2" => {
"foo" => "hier stand mal bar"
}
}
);
%Einfache_Kopie = (
"sub1" => {
"sub2" => {
"foo" => "hier stand mal bar"
}
}
);
2022-02-06T18:57:27 LinuxerDass das so ist hatte ich ja selbst schon festgestellt und in der Ursprungsfrage gezeigt. Wusste eben nur nicht, dass es erwartbares Verhalten ist, wenn sich in bestimmten Fällen das Original mit ändert.Man muss sich beide Datenstrukturen (Original und Kopie) ausgeben lassen und dann die Ausgaben vergleichen.
Wenn nur die Kopie geändert wurde, und im Original die gleiche Änderungen sichtbar werden, dann kann es keine
"saubere", tiefe Kopie gewesen sein.
2022-02-07T08:02:47 biancaOder was genau meint ihr, was ich hätte machen können/sollen, um drauf zu kommen? Denkt bitte dran, dass ich bisher noch nie so eine Situation hatte und auch nichts von flachen und tiefen Kopien wusste. Es ging bei mir also nicht nur einfach darum, ein bestimmtes erwartetes Perl Verhalten nachzuweisen sondern etwas völlig Neues zu lernen. Das hätte ich ohne euch nicht gelöst bekommen.
2022-02-06T18:14:45 biancaFalls doch zeig' mir bitte konkret, wie man das erkennen kann.
1 2 3 4 5 6 7 8 9 10 11
#!/usr/bin/perl use warnings; use strict; use Data::Dumper; my $io = {links => {refer => {entry => 10}}}; my %tmp_io = %{$io}; $tmp_io{links}{refer} = 4; print Dumper($io->{links}{refer});
$tmp_io{links}{refer} = 4;
$tmp_io{links}{refer} = 4;
$VAR1 = 4;
Can't use string ("4") as a HASH ref