Comment réécrire ce bloc eval

Question

Ce code sent ... comment est-ce que je le réécris mieux?

my $record; 

eval { 
    while (
     # undef $record here, so if getRecord() failed, nothing will be written 
     # in the reject file 
     do { undef $record; defined($record = $dataFile->getRecord) } 
    ) { 
     $LT_DataFile->encode($record); 
    } 
    1; 
}; 

if (my $error = $@) { 
    $rejectFile->writeRecord($error, $record); 
} 

Merci.

Answer 1

Ok, retravaillé ma réponse.

Je pense que le problème REAL est comment vous gérez les erreurs. Il est déroutant à première vue de voir un gestionnaire d'erreur unique lorsque vous avez plusieurs endroits où les choses pourraient mal tourner. Je vois deux alternatives.

D'abord, garder la plupart du temps la même chose que vous avez maintenant, mais il faut vérifier spécifiquement pour chaque type d'erreur:

my $record; 
eval { 
    while (defined($record = $dataFile->getRecord)) { 
     $LT_DataFile->encode($record); 
    } 
}; 
if (my $error = $@) { 
    given ($error) { 
     when (/get record error/) { $rejectFile->writeRecord($_, undef); } 
     when (/encode error/)  { $rejectFile->writeRecord($_, $record); } 
    } 
} 

De cette façon, vous êtes explicite dans la façon dont vous gérez vos erreurs. Bien sûr, avec Try :: minuscule, cela simplifie les éléments suivants dans

my $record; 
try { 
    while (defined($record = $dataFile->getRecord)) { 
     $LT_DataFile->encode($record); 
    } 
} catch { 
    when (/get record error/) { $rejectFile->writeRecord($_, undef); } 
    when (/encode error/)  { $rejectFile->writeRecord($_, $record); } 
} 

Sinon, vous pouvez ajouter l'enregistrement lexical par Daxim's answer. Cela nécessite une seconde eval ou d'essayer, plus près du problème et l'ajout d'un appel last:

eval { 
    while (defined(my $record = $dataFile->getRecord)) { 
     eval { $LT_DataFile->encode($record) }; 
     if (my $error = $@) { $rejectFile->writeRecord($error, $record); last } 
    } 
}; 
if (my $error = $@) { 
    $rejectFile->writeRecord($error, undef); 
} 

Malheureusement, cette méthode ne fonctionnera pas avec Try :: minuscule, parce que les blocs sont passés à essayer subrefs réellement.

Answer 2

Vous n'avez pas besoin d'une variable dans la partie de capture car lorsque l'exécution arrive, son contenu sera toujours undef. Remplacer cela par une valeur littérale permet de restreindre $record à une portée plus petite.

use Try::Tiny; 
try { 
    while (defined(my $record = $dataFile->getRecord)) { 
     $LT_DataFile->encode($record); 
    } 
} catch { 
    $rejectFile->writeRecord($_, undef); # T::T puts error in $_ 
} 

Answer 3

je serais factoriser la boucle while à

while (defined($record = $dataFile->getRecord)) { 
    $LT_DataFile->encode($record); 
} continue { 
    undef $record; 
} 

Le bloc continue est exécuté après chaque itération avant est testée conditionnelle. Il sera toujours appelé si votre code utilise next pour démarrer la prochaine itération tôt. Si vous n'êtes pas susceptible d'appeler next simplifiant alors le code à

while (defined($record = $dataFile->getRecord)) { 
    $LT_DataFile->encode($record); 
    undef $record; 
} 

fonctionnerait aussi bien.