push( @{ $self->{"lags"} }, {%lag_detail} );
[download]

This would push a reference to an anonymous hash which contains a current copy of your hash.

... a current copy of your hash.

A shallow copy of the hash. This may be sufficient for bartrad's use case, but I think it's always worth emphasizing the difference between shallow and deep copying.

---

Give a man a fish:  <%-{-{-{-<

The first structure appears just fine, but subsequent pushes only show as "${$VAR1}->[0]" - not sure why?

As BillKSmith mentioned, what's going on here is that you have one hash %lag_detail, and every time you push a reference to that hash onto the array, you're pushing a reference to the same one hash. This also means that when you write %lag_detail = ( ... );, you're resetting that one hash, and therefore every reference to the hash will reflect that change, which is unlikely to be what you want. That's what ${$VAR1}->[0] means: Data::Dumper is trying to tell you that the other elements of the array refer to the exact same data structure.

In essence, this is what's going on - note how both times, a reference to the same hash is pushed onto the array:

use warnings;
use strict;
use Data::Dumper;

my @array;
my %hash = ( abc=>123 );
push @array, \%hash;
%hash = ( def=>456 );
push @array, \%hash;

print Dumper(\@array);
print $array[1]{def}, "\n"; # ok
print $array[0]{abc}, "\n"; # nope! hash was cleared!

__END__

$VAR1 = [
          {
            'def' => 456
          },
          $VAR1->[0]
        ];
456
Use of uninitialized value in print at test.pl line 13.
[download]

There are a couple of ways to fix this. The one that I think is probably most applicable in this case is to change from using a hash %lag_detail to a reference to an anonymous hash (hashref), as in:

my $lag_detail;
foreach my $line ( split( /\n/, $c ) ) {
    if ( $line =~ m/someregex/ ) {
        if ( exists $lag_detail->{ports} ) {
            push( @{ $self->{lags} }, $lag_detail );
        }
        $lag_detail = { lagid => $lag, lagdesc => $4,
            operationstate => $3, adminstate => $2 };
    }
}
[download]

The reason this works is that with $lag_detail = { ... }, you're actually allocating a new anonymous hash every time and getting a reference to it. See perlreftut and perlref if you're unsure about some of the details of references.

Just for completeness, in addition to the (shallow) copying of the hash that BillKSmith suggested, a very common solution to this problem is to define the hash inside the loop, which also gets you a new hash on every iteration of the loop:

foreach my $line ( split( /\n/, $c ) ) {
    my %lag_detail;
    ...
[download]

However, since it looks to me like you're probably parsing a multiline data strucutre and don't want to push a record onto the array until it is complete, I think this is unlikely to be the correct fix in your case.

Note that you have two very similar statements in the OPed code that are doing very different things:

my %lag_detail = ...;  # single instance of this hash in scope
...
foreach my $line (...) ) {
    if (...) {
        if (...) ) {
            # push ref. to OLD instance of a hash to anon. array in an
+other hash.
            push( @{ $self->{"lags"} }, \%lag_detail );
        }
        # change certain values in hash, but hash LOCATION does not ch
+ange.
        %lag_detail = ( "lagid" => $lag, "lagdesc" => $4, "operationst
+ate" => $3, "adminstate" => $2 );
    }
}

if (...) {
    # create NEW instance of a hash in independent scope.
    # this instance is TOTALLY INDEPENDENT of any other created in thi
+s scope.
    my %port_detail = (...);
    # push ref. to NEW instance to anon. array in another hash.
    push @{ $lag_detail{"ports"} }, \%port_detail;
}
}
[download]

Set $Data::Dumper::Deepcopy to true before dumping.

#!/usr/bin/env perl

use Data::Dumper;
use strict;
use warnings;

my %hash=("one two"=>"buckle my shoe","three four"=>"shut the door");
my @arrayOfHashes;
for (1..3) {
    push @arrayOfHashes,\%hash;
    }
warn 'BEFORE: ',Data::Dumper->Dump([\@arrayOfHashes],[qw(*arrayOfHashe
+s)]),' ';
$Data::Dumper::Deepcopy=1;
warn 'AFTER: ',Data::Dumper->Dump([\@arrayOfHashes],[qw(*arrayOfHashes
+)]),' ';
[download]

BEFORE: @arrayOfHashes = (
                   {
                     'one two' => 'buckle my shoe',
                     'three four' => 'shut the door'
                   },
                   $arrayOfHashes[0],
                   $arrayOfHashes[0]
                 );
  at DataDumperDeepCopy.t line 12.
AFTER: @arrayOfHashes = (
                   {
                     'one two' => 'buckle my shoe',
                     'three four' => 'shut the door'
                   },
                   {
                     'one two' => 'buckle my shoe',
                     'three four' => 'shut the door'
                   },
                   {
                     'one two' => 'buckle my shoe',
                     'three four' => 'shut the door'
                   }
                 );
  at DataDumperDeepCopy.t line 14.
[download]

Set $Data::Dumper::Deepcopy to true before dumping.

Caveat: That only changes the way the data structure is displayed, but not the underlying data structure, that will still contain multiple references to the same hash.

Icky

 warn 'BEFORE: ',Data::Dumper->Dump([\@arrayOfHashes],[qw(*arrayOfHash
+es)]),' ';
$Data::Dumper::Deepcopy=1;
warn 'AFTER: ',Data::Dumper->Dump([\@arrayOfHashes],[qw(*arrayOfHashes
+)]),' ';
[download]

ok

 warn 'BEFORE: ',Data::Dumper->Dump([\@arrayOfHashes],[qw(*arrayOfHash
+es)]),' ';

warn 'AFTER: ',Data::Dumper->new([\@arrayOfHashes],[qw(*arrayOfHashes)
+])->Deepcopy(1)->Dump,' ';
[download]

ok? 😌

You're all the best, thank you! I'd have never figured that out.

Fix for me was to change %lag_detail to $lag_detail.