In the original data, age1 occurs two times (with potentially two different values), while in your approach, both entries will share the same value. I don't know if that is important for the OP though.

Good eye++. It is the same issue as Perl hashes though. Duplicate Object keys in JS are a mistake and will be clobbered.

<script type="text/javascript">
    var p = { "age1":"one", "age1":"two" };
    for ( var key in p ) {
        if ( p.hasOwnProperty(key) ) {
            document.write(key + " -> " + p[key] + "<br/>");
        }
    }
</script>
age1 -> two
[download]

Thank you for your time and effort with your reply

I really appreciate it.

Below is just your code with some comments/questions etc.

Would appreciate your comments at some stage.

I am really still learning Perl.

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

my $original = '{"OWNER":"KeyProjects","age1":null,"ht1":null}';
[download]

#Literal entry.

#Literal entry.

my $data = decode_json($original);
print Dumper $original;
print Dumper $desired;
print Dumper $data;
for my $key ( keys % {$data}  )
[download]

#Converts $data into a hash and cycles through it.

{
    print "Found a key: $key", $/;
    if ( $key =~ /\A (?: age\d+ | ht\d+ ) \z/x )
    {
        print "  -> It matches our regular expression\n";
        print "  -> Deleting it from data structure\n";
        my $value = delete $data->{$key};
[download]

#Does this delete the pair, the value, or what? See below.

        print Dumper $key;
[download]

#Looks like nothing is deleted.

        print Dumper $value;
[download]

#Looks like nothing is deleted.

        print "  -> Putting it back under sub-structure with key 'sche
+duled'\n";
        $data->{scheduled}{$key} = $value;
[download]

#I should understand this step but I don't really know what each aspect of this line is doing.

        print Dumper $key;
        print Dumper $value;
        print Dumper $data;
    }
    else
    {
        print "  -> It's fine where it is, no action taken\n";
        print Dumper $key;
        print Dumper $data;
    }
}

print encode_json( $data ), $/;


use Test::More;
my $desired_data = decode_json( $desired );
is_deeply( $desired_data, $data, "Data structures match" );
done_testing(1);
[download]

I’m glad it’s got you thinking. Here’s a little more to play with. The only part it answers directly is the delete function. I think you will start to understand more the more you play around with the code. Part of what makes Perl so easy/fun is how easy it is to test ideas, adjust and run. Remember, you have great built-in documentation. Just run perldoc -f delete for functions for example. Or perldoc perltoc or perldoc Data::Dumper, etc… :P

use strict;
use warnings;
use Data::Dumper;
$Data::Dumper::Terse = 1; # Raw structures, no $VAR1 style names.

# One hash, with a (hash) reference taken to it–
my %stuff = ( somekey => "someval", o => "hai" );
my $stuff_ref = \%stuff; # reference literally *references* original.
print "Same hash, two ways to access: $stuff{o} eq $stuff_ref->{o}\n";

# See the hash right now.
print "Original hash: ", Dumper( $stuff_ref );

my $value = delete $stuff_ref->{o};
print "Hash after deleting key o: ", Dumper( $stuff_ref );
print "Print it directly (uninitialized now): o => ", $stuff_ref->{o},
+ $/;

# Add a new dimension to the data–
$stuff_ref->{new_key}{sub_key} = "new value";

# Give it a friend, old key/value, new position–
$stuff_ref->{new_key}{o} = $value;

print "Hash after moving stuff around: ", Dumper( $stuff_ref );

$stuff_ref->{as}{deep}{as}{you} = "please";
$stuff_ref->{as}{deep}{as}{array_ref} = [ "one", "two" ];
$stuff_ref->{subroutine} = sub { print "OHAI!\n" };
$stuff_ref->{fancy_data} = [ "one", { two => "is a hash(ref)" }, ["ano
+ther","array"], "last" ];

print "Perl data structures are *flexible* ", Dumper( $stuff_ref );

print "Excecuting code ref through data...";
$stuff_ref->{subroutine}->();
[download]

Read more... (2 kB)
(Update: I'm not missing <ins>you</ins> at all… now.)

Thank you, again

So interesting

Before I knew about what data in MongoDB looked like, I looked at a complex structure of hashes and arrays and thought, if one could set up a structure and had a way of inserting data into it easily, then it would be a visibly useful way of storing data. Low and behold, it seems to be the case.

Not that I have any knowledge or ability concerning MongoDB, hashes, or other stuff like them.

That's how I started looking at Mongo a few weeks ago. It's fascinating. I've taught myself a little sql. I'm looking for a reason to adapt my sql data to use it in Mongo, but I can't at present see any valid reason for doing that. Pity.

Thank you very much for your help with this.

I understand:

my $value = delete $stuff_ref->{o};

and your data structure examples, and manipulating them, better now.