Preserve a variable's value across multiple subroutine calls in perl

Question

Just wanted to know what was the best way to reserve the value of a variable across multiple calls to the same subroutine . i.e

$someList  = &someRoutine(100, 200);
$someList2 = &someRoutine(100, 200);

sub someRoutine {
    $someAddition = 0;
    foreach $someSum (@_){
        $someAddition += $someSum;
    }
    return $someAddition
}

print $someList;
print $someList2;

Basically, someList should print 300 and someList2 should print 600. How do i make it so that someList2 prints 600? i want $someAddition to be preserved across multiple subroutine calls.

DavidO · Accepted Answer · 2017-01-25 23:02:05Z

6

There are several ways to do it. I'll demonstrate two of them:

First, in modern versions of Perl you can use state:

use feature qw/state/; 

print someRoutine(100,200), "\n";
print someRoutine(100,200), "\n";

sub someRoutine {
    state $someAddition = 0;
    foreach my $someSum ( @_ ) {
        $someAddition += $someSum;
    }
    return $someAddition;
}

In this version, the $someAddition variable will be initialized to zero once, and only once. From that point on, the value will be retained between calls.

Another version is using a lexical closure. Here's an example:

my $summer = makeSummer();
print $summer->(100,200), "\n";
print $summer->(100,200), "\n";

sub makeSummer {
    my $someAddition = 0;
    return sub {
        $someAddition += $_ foreach @_;
        return $someAddition;
    }
}

The second version is a little more complex, but has two advantages. First, you can start a fresh summation simply by calling the makeSummer routine to manufacture a new closure. Second, it will work on any version of Perl 5, not just versions recent enough to have the newer state keyword.

If you are not concerned with initializing the stateful variable before the sub is declared, you can also do this:

my $someAddition;
sub someRoutine {
    $someAddition = 0 unless defined $someAddition;
    foreach my $someSum( @_ ) {
        $someAddition += $someSum;
    }
    return $someAddition;
}

A fourth method makes use of package globals. I save this one for last because it's the most prone to abuse and mistakes. But here you go;

our $someAddition = 0;

someRoutine(100,200);
print "$someAddition\n";

someRoutine(100,200);
print "$someAddition\n";

sub someRoutine {
    $someAddition += $_ foreach @_;
}

In this last version, $someAddition is a package global, and its global scope makes it available both inside and outside of any subroutines living within the same namespace.

edited Jan 25, 2017 at 23:02

answered Feb 8, 2015 at 5:57

DavidO

14k4 gold badges41 silver badges67 bronze badges

Sign up to request clarification or add additional context in comments.

9 Comments

user2128074 Over a year ago

Thank you for your answers. Unfortunately, the perl version we use at our school is pretty old so state would not work, also, i need to have the subroutine return an array with a multitude of items in the array, so i don't know whether the lexical closure one will work. Is there any other way?

DavidO Over a year ago

return ( $someAddition, [@array] ); Perl's return values don't have to be homogeneous entities.

user2128074 Over a year ago

Sorry if i didn't explain it correctly , but $someAddition is part of the array i am returning.

DavidO Over a year ago

Then the closure method should work. But if you prefer using package globals instead, see the third example, provided in my most recent edit.

DavidO Over a year ago

You can read about closures in perldoc.perl.org/perlsub.html#Persistent-Private-Variables

|

Borodin · Accepted Answer · 2015-02-08 14:11:07Z

I assume you're at least using a variant of Perl 5? It has been bad practice to use ampersands & on subroutine calls since the first version of Perl 5 twenty-two years ago.
It is also vital that you use strict and use warnings at the top of every Perl program, and declare your variables ay their first point of use with my. It is a measure that will uncover many simple coding errors that you can otherwise easily overlook.
Perl variable names should use only lower-case letters, digits, and underscores. Capital letters are reserved for global identifiers such as package names.

By far the simplest and most common way of creating a static variable is just to declare it outside the subroutine. Like this

use strict;
use warnings;

my $some_list  = some_routine(100, 200);
my $some_list2 = some_routine(100, 200);

my $some_addition;

sub some_routine {
  $some_addition += $_ for @_;
  return $some_addition
}

print $some_list, "\n";
print $some_list2, "\n";

output

300
600

If you want to protect the variable from being accessed by any following code other than the subroutine, then just enclose them in braces, like this

{
  my $some_addition;

  sub some_routine {
    $some_addition += $_ for @_;
    return $some_addition
  }
}

AnFi · Accepted Answer · 2015-02-08 06:27:45Z

3

Take a look at Persistent Private Variables in "man perlsub".

answered Feb 8, 2015 at 6:27

AnFi

11k3 gold badges27 silver badges54 bronze badges

Collectives™ on Stack Overflow

Preserve a variable's value across multiple subroutine calls in perl

3 Answers 3

9 Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

9 Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related