J'ai une fonction de vérification de valeur, quelque chose comme une fonction de vérification de numéro de carte de crédit, qui est passée dans une chaîne et doit vérifier que la valeur est au bon format.
Si c'est le bon format, il doit retourner vrai.
Si ce n'est pas le bon format, il doit retourner false, et nous dire également ce qui ne va pas avec la valeur.
La question est, quelle est la meilleure façon d'y parvenir?
Voici quelques solutions:
1. Utilisez des codes de retour entiers / énumérés pour signifier les significations:
String[] returnCodeLookup =
[
"Value contains wrong number of characters, should contain 10 characters",
"Value should end with 1",
"Value should be a multiple of 3"
]
private int valueChecker(String value)
{
/*check value*/
return returnCode;
}
rc = checkValue(valueToBeChecked);
if rc == 0
{
/*continue as normal*/
}
else
{
print("Invalid value format: ") + returnCodeLookup[rc];
}
Je n'aime pas cette solution car elle nécessite une implémentation côté appelant.
2. Créez une classe returnCode
Class ReturnCode()
{
private boolean success;
private String message;
public boolean getSuccess()
{
return this.success;
}
public String getMessage()
{
return this.message;
}
}
private ReturnCode valueChecker(String value)
{
/*check value*/
return returnCode;
}
rc = checkValue(valueToBeChecked);
if rc.getSuccess()
{
/*continue as normal*/
}
else
{
print("Invalid value format: ") + rc.getMessage();
}
Cette solution est bien rangée, mais il semble que ce soit exagéré / réinventer la roue.
3. Utilisez des exceptions.
private boolean valueChecker(String value)
{
if int(value)%3 != 0 throw InvalidFormatException("Value should be a multiple of 3";
/*etc*/
return True;
}
try {
rc = checkValue(valueToBeChecked);
}
catch (InvalidFormatException e)
{
print e.toString();
}
Je suis tenté d'utiliser cette solution, mais on me dit que vous ne devez pas utiliser d'exceptions pour la logique métier.
la source
Réponses:
Utilisez un objet de retour plus complexe qui résume les deux problèmes. Exemple:
Cela présente plusieurs avantages:
J'ai déjà utilisé cette conception spécifique auparavant, dans des applications où une validation peut être plus que simplement vraie ou fausse. Un message détaillé est peut-être nécessaire, ou seule une partie de l'entrée n'est pas valide (par exemple, un formulaire à dix éléments peut ne comporter qu'un ou deux champs non valides). En utilisant cette conception, vous pouvez facilement répondre à ces exigences.
la source
IValidationResult.SUCCESS
qui renvoie un message d'erreur vide. Ensuite, votre logique ressemble àif (result != SUCCESS) { doStuff(result.getMessage()); }
Aucune de ces réponses, utilisez une classe ValueChecker
D'abord une interface pour vous donner de la flexibilité:
Ensuite, implémentez autant de vérificateurs de valeur que vous le souhaitez:
Exemple de code client:
Il a l'avantage que vous pouvez avoir de nombreux contrôleurs de valeur différents.
la source
Ma réponse étend l'approche de @ Snowman. Fondamentalement, chaque validation, chaque règle métier et chaque logique métier devrait pouvoir donner lieu à une certaine réponse - au moins, dans les applications Web. Cette réponse, à son tour, est affichée pour un appelant. Cela m'a amené à l'interface suivante (c'est php, mais la question est indépendante de la langue):
La création d'un opérateur de commutateur agissant comme une expression, et non comme une instruction, conduit à un service d'application ressemblant à ceci:
la source