How to read values assigned inside a script, in a program that runs that script?

In short, you need to pass data from a program back to the program that invoked it.

If the called program (sub_script.pl) needs to return only simple values then it can just print them to STDOUT, where the calling program (main.pl) runs it via "backticks" (qx in the operator form), which returns the program's STDOUT.

However, more complex data structures need be serialized so that they can be meaningfully sent down a pipe (of some kind) byte by byte. There are various ways to do so, with good libraries, and simple code below demonstrates two of them.

The JSON format is very simple, human readable, and accessible from any language and system. Perl libraries for conversion between Perl data structures and corresponding JSON are very simple to use. This is a good and safe solution for a wide range of situations.

Perl's Storable is a tool for persistency, so that complex data structures can be dumped to disk and later restored from the file. One can also serialize data to strings that can be passed between programs with no need for files.

The program sub_script.pl below creates a hash and makes a JSON string out of it and prints it, and then also serializes the hash into a Storable string which it also prints

use warnings;
use strict;
use feature 'say';

use JSON;
use Storable qw(nfreeze);

my %h = (a => { A => 1}, b => { B => 2 }); 

my $str_json = encode_json \%h;
say $str_json;

my $str_st = nfreeze \%h;
say $str_st;

The following program (main.pl) runs the sub_script.pl above using qx so that it receives its STDOUT, and then it rebuilds the hash from both the JSON and Storable strings. In both cases we get back a hashref, a reference to data like the original hash

use warnings;
use strict;
use feature 'say';

use JSON;
use Storable qw(thaw);

use Data::Dump qw(dd);

my @ret = qx( sub_script.pl );
chomp @ret;

my $hr1 = decode_json $ret[0];
dd $hr1;

my $hr2 = thaw $ret[1];
dd $hr2;

I use JSON for simplicity, which will use the fast JSON_XS if installed, or the pure-Perl fallback, the core JSON_PP. Another option is Cpanel::JSON::XS, a fork of JSON_XS.

To print complex data structures so to see them easily I use Data::Dump, which probably need be installed. There is a number of other good modules to show complex data, the most widely used one being the core Data::Dumper (so no need to install).

In all of this, the program that is called still just prints to its STDOUT. When data exchange needs get more complex you may need to use some "Inter-Process-Communication" (IPC) techniques.