Если у меня есть хеш Perl с кучей пар (ключ, значение), каков предпочтительный метод итерации через все ключи? Я слышал, что использование each может каким-то образом иметь непреднамеренные побочные эффекты. Итак, это правда, и один из двух следующих методов лучше, или есть лучший способ?
# Method 1
while (my ($key, $value) = each(%hash)) {
# Something
}
# Method 2
foreach my $key (keys(%hash)) {
# Something
}
Эмпирическое правило - использовать функцию, наиболее подходящую для ваших нужд.
Если вы просто хотите использовать ключи и не планируете когда-либо читать какие-либо значения, используйте клавиши():
foreach my $key (keys %hash) { ... }
Если вам просто нужны значения, используйте значения():
foreach my $val (values %hash) { ... }
Если вам нужны ключи и значения, используйте каждый():
keys %hash; # reset the internal iterator so a prior each() doesn't affect the loop
while(my($k, $v) = each %hash) { ... }
Если вы планируете менять ключи хэша любым способом, кроме удаления текущего ключа во время итерации, вы не должны использовать each(). Например, этот код для создания нового набора прописных ключей с удвоенными значениями отлично работает с помощью клавиш():
%h = (a => 1, b => 2);
foreach my $k (keys %h)
{
$h{uc $k} = $h{$k} * 2;
}
создает ожидаемый результат хеширования:
(a => 1, A => 2, b => 2, B => 4)
Но используя каждый(), чтобы сделать то же самое:
%h = (a => 1, b => 2);
keys %h;
while(my($k, $v) = each %h)
{
$h{uc $k} = $h{$k} * 2; # BAD IDEA!
}
дает неверные результаты в труднодоступных для прогнозирования способах. Например:
(a => 1, A => 2, b => 2, B => 8)
Это, однако, безопасно:
keys %h;
while(my($k, $v) = each %h)
{
if(...)
{
delete $h{$k}; # This is safe
}
}
Все это описано в документации perl:
% perldoc -f keys
% perldoc -f each
Одна вещь, о которой вам следует знать при использовании each, заключается в том, что она имеет
побочный эффект добавления "состояния" к вашему хешу (хэш должен помнить
что такое "следующий" ключ). Когда вы используете код, подобный приведенным выше фрагментам,
которые перебирают весь хэш за один раз, обычно это не
проблема. Тем не менее, вы столкнетесь с трудностями для выявления проблем (я говорю из
опыт;) при использовании each вместе с операторами типа
last или return для выхода из цикла while ... each
обработали все ключи.
В этом случае хэш будет помнить, какие ключи он уже вернулся, и
когда вы используете each на нем в следующий раз (возможно, в полностью несвязанной части
кода), он будет продолжаться в этом положении.
Пример:
my %hash = ( foo => 1, bar => 2, baz => 3, quux => 4 );
# find key 'baz'
while ( my ($k, $v) = each %hash ) {
print "found key $k\n";
last if $k eq 'baz'; # found it!
}
# later ...
print "the hash contains:\n";
# iterate over all keys:
while ( my ($k, $v) = each %hash ) {
print "$k => $v\n";
}
Отпечатки:
found key bar
found key baz
the hash contains:
quux => 4
foo => 1
Что случилось с клавишами "бар" и "база"? Они все еще там, но
второй each начинается там, где первый отключился, и останавливается, когда он достигает конца хэша, поэтому мы никогда не видим их во втором цикле.
Место, где each может вызывать проблемы, - это истинный, не-облачный итератор. В качестве примера:
while ( my ($key,$val) = each %a_hash ) {
print "$key => $val\n";
last if $val; #exits loop when $val is true
}
# but "each" hasn't reset!!
while ( my ($key,$val) = each %a_hash ) {
# continues where the last loop left off
print "$key => $val\n";
}
Если вам нужно убедиться, что each получает все ключи и значения, вам нужно сначала использовать keys или values (так как это сбрасывает итератор). См. Документацию для каждого.
Использование каждого синтаксиса предотвратит создание всего набора ключей одновременно. Это может быть важно, если вы используете привязку с привязкой к базе данных с миллионами строк. Вы не хотите генерировать весь список ключей одновременно и исчерпывать свою физическую память. В этом случае каждый выступает в качестве итератора, тогда как ключи фактически генерируют весь массив до начала цикла.
Таким образом, единственным местом "каждый" является реальное использование, когда хэш очень большой (по сравнению с доступной памятью). Это может произойти только тогда, когда сам хэш не живет в самой памяти, если вы не программируете карманное устройство сбора данных или что-то с небольшой памятью.
Если память не является проблемой, обычно парадигма карты или ключей является более предсказуемой и более простой для чтения парадигмой.
Я всегда использую метод 2. Единственное преимущество использования каждого заключается в том, что вы просто читаете (а не переписываете) значение хэш-записи, вы не постоянно удаляете хеш-ссылку.
Несколько разных мыслей по этой теме:
values возвращает псевдонимы, что означает, что их изменение будет изменять содержимое хэша. Это по дизайну, но может быть не так, как вы хотите в некоторых обстоятельствах.each. Это неверно для keys, поскольку each является итератором, а keys возвращает список.Я могу укусить этот, но я думаю, что это личное предпочтение. Я не могу найти ссылку в документах для каждого(), отличного от ключей() или значений() (за исключением очевидных "они возвращают разные вещи" ). Фактически документы указывают, что используют один и тот же итератор, и все они возвращать фактические значения списка вместо их копий и что изменение хэша при повторном использовании его с использованием любого вызова плохое.
Все, что сказал, я почти всегда использую ключи(), потому что для меня обычно более самодокументируется доступ к значению ключа через сам хеш. Иногда я использую значения(), когда значение является ссылкой на большую структуру, а ключ к хешу уже сохранен в структуре, после чего ключ избыточен и мне не нужен. Я думаю, что я использовал каждый() 2 раза за 10 лет программирования Perl и, вероятно, был неправильным выбором оба раза =)
Я обычно использую keys, и я не могу вспомнить последний раз, когда использовал или читал использование each.
Не забывайте о map, в зависимости от того, что вы делаете в цикле!
map { print "$_ => $hash{$_}\n" } keys %hash;
Я скажу:
Это дает два основных преимущества:
Я не думаю, что более дорого использовать ключи по каждому, поэтому нет необходимости в двух разных конструкциях для одного и того же кода в вашем коде.