sub call_variables {
    split /~/ => scalar param 'spec_vars'
}
[download]

In general, if you want to share code, one uses use, or require and sometimes do. You may want to make use of the Exporter module to export names from the called package to the calling package.

Abigail

I've no idea what you want to do. &call_variables doesn't expose any variables to the outside - all it does is return values.

Exactly my problem. I'll try to further (and hopefully better) explain what I want to do.

I have a section of code that I'm using in several programs. The section looks exactly like what is inside the sub I described above (no variation nor different values assigned, etc). If it were possible, I would copy and paste that section into every program it needs to go into. Of course, while you're running programs you can't very well say, "Hold on, I need to copy and paste that text into the program before you run it!" I'm using the same 25 lines of code (get the param, split the array, assign the variables their $array values), so I was looking for a way to somehow automagically insert that section each time.

I read the POD about Exporter. If I understand Abigail-II and arden correctly, Exporter will let me put my repeating section of code in a .pm package that I use or require. However, it seems like I'll still need to declare all the variables (my $one, my $two) near the beginning of each program that will be calling the sub. Do I have that right?

So, I would end up with something like:

#!/usr/local/bin/perl5_8
use strict;
use Exporter;
use myVars;     #this would be my own myVars.pm
use CGI;
use CGI ':standard';
use CGI::Carp qw(fatalsToBrowser);
my $CGI = CGI->new;

$|=1;
print $CGI->header;

my ($one, $two .... $twenty-five);
#call my variables that are always the same
&call_variables;

#do other stuff using these called-in variables
#without having to declare "my $one" and "my $two" again
$fred = $one . $two;    #or some such silliness
[download]

This would be in the myVars.pm file:

sub call_variables {
#pick up a string I've passed from previous program via 'spec_vars'
my $spec_vars = param('spec_vars');
   return (split /~/, $spec_vars)[0,1,2,3,4 .. 25];
}
[download]

That means that the above new stuff would be the same as if I had typed in this section into a program instead of calling the sub - is that right?

$one = $spec_vars[0];
$two = $spec_vars[1];
etc.
[download]

In the meantime, I'll be reading up on use and require to better understand the difference.

Lori

How well did you read the Exporter manual page? It nowhere suggest that a mere use Exporter; peeks inside your brain and knows which tokens to export.

For starters, you use the Exporter module from the module you want to *drumroll* export from. So, myVars, in your case. Then you need to subclass your exporting module to be a subclass of Exporter - that's what the @ISA line is doing in the SYNOPSIS of the manual page. Finally, you need to tell Exporter what you want to export, that's where you use @EXPORT, @EXPORT_OK and/or %EXPORT_TAGS.

Please study the manual pages (for instance perlmod), a book or a tutorial about writing modules.

Abigail

Otherwise, just declare them at the top of your program, and make call_variables update them. Don't put my $one = ... inside the function because that would create lexicals in the scope of the function body (not what you want).

With hash:

# [at the top, before subroutine definitions and code]
my %my_vars;
# [...]

sub call_variables {
  #pick up a string I've passed from previous program via 'spec_vars'
  my $spec_vars = param('spec_vars');
  @my_vars{qw/one two three four five/} = split /~/, $spec_vars;
}
[download]

With globals (file-scoped lexicals, not dynamic variables):

# [at the top, before subroutine definitions and code]
my ($one, $two, $three, $four, $five);
# [...]

sub call_variables {
  #pick up a string I've passed from previous program via 'spec_vars'
  my $spec_vars = param('spec_vars');
  ($one, $two, $three, $four, $five) = split /~/, $spec_vars;
}
[download]

If you don't want to declare them, you have to use fully scoped package variable names such as $::one under use strict. The variables will be dynamic, of course.

Update: replaced @my_vars{one, two, three, four, five} with @my_vars{qw/one two three four five/}

I'm not entirely sure what you're asking for, but I suspect you can benefit from array slices:

sub call_variables 
{
    my $spec_vars = param('spec_vars');
    return (split /~/, $spec_vars)[0,1,2,3,4];
}
[download]

Another option would be to have the variables exported by creating your own package that gets the variables and putting use myvariables; at the beginning of your code, but that would require more work (although it might be "The Right Way"™ to do it).