Там некоторый путь состоит в том, чтобы сделать переменные как $a и $b в отношении строгого?

Другие упомянули, как 'использовать Вар' и 'наш' - я просто хотел добавить, что $a и $b являются особыми случаями, так как они используются внутренне программами сортировки. Вот примечание из strict.pm документов:

Because of their special use by sort(), the variables $a and $b are 
exempted from this check.

Если я понимаю правильно, что Вы хотите:

use vars qw($a $b); # Pre-5.6

или

our ($a, $b); # 5.6 +

Можно читать об этом здесь.

$a и $b являются особенными, потому что они - часть базового языка. В то время как я вижу, почему Вы могли бы сказать, что неспособность создать собственные так-же-специальные-переменные является anti-TIMTOWTDI, я сказал бы, что это больше не, чем неспособность создать новые основные команды на порядке 'печати' или 'вида'. (Можно определить нижние индексы в модулях, но это не делает их истинными ключевыми словами. Это - эквивалент использования 'нашего $k', который Вы, кажется, говорите, не делает $k достаточно как $a для Вас.)

Для продвижения имен в чужое пространство имен это должно быть рабочим примером Средства экспорта:

package SpecialK;

use strict;

use base 'Exporter';
BEGIN {
  our @EXPORT = qw( $k );
}

our $k;

1;

Сохраните это к SpecialK.pm и 'использует SpecialK', должен затем сделать $k доступным для Вас. Обратите внимание, что только 'наши' переменные могут быть экспортированы, не 'мой'.

В Perl 5.6 и позже, можно использовать наш:

our ($k, $v);

Или можно продолжить работать с более старым "использованием Вар":

use vars qw($k $v);

Или Вы могли бы просто придерживаться "моего", например:

my %hash;
my ($k,$v);
while (<>) {
  /^KEY=(.*)/ and $k = $1 and next;
  /^VALUE=(.*)/ and $v = $1;
  $hash{$k} = $v;
  print "$k $v\n";
}

__END__
KEY=a
VALUE=1
KEY=b
VALUE=2

Создание глобального $v не действительно необходимо в примере выше, но надо надеяться Вы получаете идею ($k, с другой стороны, должен быть ограничен по объему вне в то время как блок).

С другой стороны, можно использовать полностью определенные имена переменной:

$main::k="foo";
$main::v="bar";
%main::hash{$k}=$v;

Это работало на меня:

package Special;
use base qw<Exporter>;
# use staging; -> commented out, my module for development
our $c;

our @EXPORT = qw<manip_c>;

sub import { 
    *{caller().'::c'} = *c;
    my $import_sub    = Exporter->can( 'import' );
    goto &$import_sub;
 } 

И это передает $c через строгий, также.

package main;
use feature 'say';
use strict;
use Special;
use strict;
say "In main: \$c=$c";

manip_c( 'f', sub {
    say "In anon sub: \$c=$c\n"; # In anon sub: $c=f
});

say "In main: \$c=$c";

Да, это является довольно немым, что я заключил в скобки свои модули с "использованием, строгим", но я не знаю внутренности, и это заботится о потенциальных проблемах упорядочивания.

Это кажется, что Вы хотите сделать вид волшебства это List::MoreUtils делает:

use strict;
my @a = (1, 2);
my @b = (3, 4);
my @x = pairwise { $a + $b } @a, @b;

Я предложил бы просто смотреть на pairwise sub в List::MoreUtils источник. Это использует некоторую умную таблицу символов, играющую для введения $a и $b в пространство имен вызывающей стороны и затем локализуют их к только в sub теле. Я думаю.

$a и $b просто глобальные переменные. Можно достигнуть подобных эффектов путем простого объявления $k и $v:

use strict;
our ($k, $v);

(В этом случае $k и $v не глобальные переменные, но лексически ограниченные по объему псевдонимы для переменных пакета. Но если Вы не пересекаете границы, это так же достаточно.)

$a и $b не являются нормальными переменными, тем не менее, и не могут легко копироваться или лексическими объявлениями или явным экспортом или имением предосудительные отношения с таблицей символов. Например, с помощью отладчика в качестве оболочки:

  DB<1> @foo = sort { $b cmp $a } qw(foo bar baz wibble);

  DB<2> x @foo
0  'wibble'
1  'foo'
2  'baz'
3  'bar'
 DB<3> x $a
0  undef
  DB<4> x $b
0  undef

$a и $b только существуют в блоке, переданном виду (), не существуйте впоследствии и имейте объем таким способом, которым дальнейшие вызовы к виду не наступают на них.

Для тиражирования этого, вероятно, необходимо начать иметь предосудительные отношения с фильтрами источника, поворачивать предпочтительную нотацию

my %starts_upper_1_to_25 
    = skim { $k =~ m/^\p{IsUpper}/ && ( 1 <= $v && $v <= 25 ) } %my_hash
;

в эффективно

my %starts_upper_1_to_25
    = map { my $k = $_; my $v = $my_hash{$v};
            $k =~ m/^\p{IsUpper}/ && ( 1 <= $v && $v <=> 25 ) } keys %my_hash
;

$a и $b являются столь же особенными как $ _ и _, и в то время как нет никакого простого способа изменить те имена в Perl 5, Perl 6 действительно фиксирует это с данным ключевым словом. "данный" мусорный термин для поиска на, но http://dev.perl.org/perl6/doc/design/syn/S03.html может быть хорошим местом для запуска.

Я не уверен, разъяснил ли кто-либо, что это, но строгий не добавляет в белый список $a и $b просто, потому что они - действительно удобные имена переменной для Вас для использования в собственных стандартных программах. $a и $b имеют особое значение для оператора вида. Это хорошо с точки зрения в рамках такой программы сортировки, но вида плохого дизайна снаружи.:) Вы не должны использовать $a и $b в других контекстах, если Вы.

Это что Ваш после?.....

use strict;
use warnings;
use feature qw/say/;

sub hash_baz (&@) {
    my $code   = shift;  
    my $caller = caller;
    my %hash   = (); 
    use vars qw($k $v);

    no strict 'refs';
    local *{ $caller . '::k' } = \my $k;
    local *{ $caller . '::v' } = \my $v;

    while ( @_ ) {
        $k = shift;
        $v = shift;
        $hash{ $k } = $code->() || $v;
    }

    return %hash;
}

my %hash = ( 
    blue_cat   => 'blue', 
    purple_dog => 'purple', 
    ginger_cat => 'ginger', 
    purple_cat => 'purple' );

my %new_hash = hash_baz { uc $v if $k =~ m/purple/ } %hash;

say "@{[ %new_hash ]}";

# =>  purple_dog PURPLE ginger_cat ginger purple_cat PURPLE blue_cat blue

Модули предположили, что экспорт использования действительно не отличается от use vars. Но use vars должен был бы быть сделан в каждом пакете, который использовал переменную $a-like. И our() должен был бы быть сделан в каждом внешнем объеме.

Обратите внимание, что можно избегать использования $a, и $b даже для вида при помощи $$ - моделировал sub:

sub lccmp($$) { lc($_[0]) cmp lc($_[1]) }
print join ' ', sort lccmp
   qw/I met this guy and he looked like he might have been a hat-check clerk/;

Это важно при использовании сравнить стандартной программы в другом пакете, чем вызов вида.

РЕДАКТИРОВАНИЕ - это на самом деле неправильно, см. комментарии. Отъезд его здесь, чтобы дать другим людям шанс научиться на моей ошибке :)

О, Вы спрашиваете, существует ли путь к модулю для объявления $k и $v в пространстве имен ВЫЗЫВАЮЩЕЙ СТОРОНЫ? Можно использовать Средство экспорта для увеличивания переменных вызывающей стороне:

use strict;

package Test; 
use Exporter;

my @ISA = qw/Exporter/; 
my $c = 3; 
my @EXPORT = qw/$c/; 

package main; 
print $c;