Какой самый безопасный способ перебирать ключи Perl-хеша?

Одна вещь, о которой вам следует знать при использовании 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 (так как это сбрасывает итератор). См. Документацию для каждого.

Использование каждого синтаксиса предотвратит создание всего набора ключей одновременно. Это может быть важно, если вы используете привязку с привязкой к базе данных с миллионами строк. Вы не хотите генерировать весь список ключей одновременно и исчерпывать свою физическую память. В этом случае каждый выступает в качестве итератора, тогда как ключи фактически генерируют весь массив до начала цикла.

Таким образом, единственным местом "каждый" является реальное использование, когда хэш очень большой (по сравнению с доступной памятью). Это может произойти только тогда, когда сам хэш не живет в самой памяти, если вы не программируете карманное устройство сбора данных или что-то с небольшой памятью.

Если память не является проблемой, обычно парадигма карты или ключей является более предсказуемой и более простой для чтения парадигмой.

Несколько разных мыслей по этой теме:

• Существует ничего небезопасного ни о каких итераторах хэширования. Что небезопасно, это изменение ключей хеша, когда вы повторяете его. (Совершенно безопасно изменять значения.) Единственный потенциальный побочный эффект, о котором я могу думать, заключается в том, что values возвращает псевдонимы, что означает, что их изменение будет изменять содержимое хэша. Это по дизайну, но может быть не так, как вы хотите в некоторых обстоятельствах.
• John принятый ответ хорош с одним исключением: в документации ясно, что небезопасно добавлять ключи во время итерации по хэшу. Он может работать для некоторых наборов данных, но не подходит для других в зависимости от хэш-порядка.
• Как уже отмечалось, безопасно удалять последний ключ, возвращаемый each. Это неверно для keys, поскольку each является итератором, а keys возвращает список.

Я всегда использую метод 2. Единственное преимущество использования каждого заключается в том, что вы просто читаете (а не переписываете) значение хэш-записи, вы не постоянно удаляете хеш-ссылку.

Я могу укусить этот, но я думаю, что это личное предпочтение. Я не могу найти ссылку в документах для каждого(), отличного от ключей() или значений() (за исключением очевидных "они возвращают разные вещи" ). Фактически документы указывают, что используют один и тот же итератор, и все они возвращать фактические значения списка вместо их копий и что изменение хэша при повторном использовании его с использованием любого вызова плохое.

Все, что сказал, я почти всегда использую ключи(), потому что для меня обычно более самодокументируется доступ к значению ключа через сам хеш. Иногда я использую значения(), когда значение является ссылкой на большую структуру, а ключ к хешу уже сохранен в структуре, после чего ключ избыточен и мне не нужен. Я думаю, что я использовал каждый() 2 раза за 10 лет программирования Perl и, вероятно, был неправильным выбором оба раза =)

Я обычно использую keys, и я не могу вспомнить последний раз, когда использовал или читал использование each.

Не забывайте о map, в зависимости от того, что вы делаете в цикле!

map { print "$_ => $hash{$_}\n" } keys %hash;

Я скажу:

• Использовать все, что проще для чтения/понимания для большинства людей (так что ключи, как правило, я бы утверждал)
• Используйте все, что вы решите последовательно на всей базе кода.

Это дает два основных преимущества:

• Легче определить "общий" код, чтобы вы могли перегруппировать в функции /methiods.
• Это проще для будущих разработчиков.

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