I would declare it only once, like this:

#!/usr/bin/env -S perl -n
use strict;
use warnings;

# USAGE:  perl np.pl <np.dat
our $total;

BEGIN{
    $total = 0;
}

$total += $_;

END{
    print $total
}
[download]

This seems less verbose while retaining the clarity but it is all subjective, of course.

[Deleted incorrect comment.]

For stuff like this I kind of cheat and use -M'5;my $total = 0;' instead (although I wouldn't just for zero since undef does the right thing anyhoo). That along with the eskimo kiss trick (closing the implicit -n or -p while block with }{ ; using -MO=Deparse can show what you're really getting) lets you handle most things.

perl -F, -M'5;my $t = 0' -lanE '$t += $F[2];}{ say $t' some_file.csv
[download]

Edit: And I'd never use -n in a shebang line, just when trying for a (too) clever / short one-liner. If you're not golfing or sticking this in the middle of a pipeline it's much better to be explicit in your script and not need to bother with tricks to get reasonable scoping.

Hence you are declaring 3 different² variables in your code.

Since declarations happen at compile time it's safe to have only one in the surrounding scope (block or file) This will cover all nested scopes.

Like demonstrated by hippo in the other reply on the file scope.

Updates

¹) See https://perldoc.perl.org/5.6.0/perldelta#%22our%22-declarations

²) That's probably confusing, three different lexical aliases are declared, but all store inside the same package variable. It's just that the values are switched whenever the scope is changing, giving the appearance of different variables. Similar to local

Using -n just complicates things for nothing.

With -n:

#!/usr/bin/perl -n

use strict;
use warnings;

our $total;

BEGIN {
   $total = 0;
}

$total += $_;

END {
   print $total, "\n";
}
[download]

Without -n:

#!/usr/bin/perl

use strict;
use warnings;

my $total = 0;

while ( <> ) {
   $total += $_;
}

print $total, "\n";
[download]

One is clearly a million times better.

Using -n just complicates things for nothing.

With -n:

#!/usr/bin/perl -n

use strict;
use warnings;

our $total;

BEGIN {
   $total = 0;
}

$total += $_;

END {
   print $total, "\n";
}
[download]

Without -n:

#!/usr/bin/perl

use strict;
use warnings;

my $total = 0;

while ( <> ) {
   $total += $_;
}

print $total, "\n";
[download]

One is clearly a million times better.

It might make more sense if expressed as a one-liner.

$ for i in {1..10}; do echo $i; done | perl -ne 'BEGIN {our $prod = 1;
+} $prod *= $_; END { print $prod,$/; }'
3628800
[download]

90% of every Perl application is already written. ⇒

dragonchild

I wasn't saying that BEGIN is never useful. I was talking about in the situation at hand.

But even in your entirely different scenario, does it really make sense?

perl -nle'BEGIN { $prod = 1; } $prod *= $_; END { print $prod; }'
[download]

vs

perl -le'$prod = 1; $prod *= $_ while <>; print $prod;'
[download]