Comment s'appelle cette technique de programmation?

Je suis tombé sur cette technique de programmation lors d'une programmation en binôme dans une interview et je n'ai pas pu trouver le nom de celle-ci sur Google.

L'idée est que vous écriviez d'abord l'expression qui utilise les variables, puis que vous écriviez le code qui calcule les variables plus tard.

Pour utiliser un exemple de code ici:

private bool ValidPolicyNumber(string policyNumber) 
{
    var hasExpectedPrefix = policyNumber.Substring(0,5) == "POLIC";
    var followedBy7Digits = Regex.IsMatch(policyNumber.Substring(6,7), "^[0-9]{7}$");
    var hasLengthOf12 = policyNumber.Length == 12;

    return hasExpectedPrefix && followedBy7Digits && hasLengthOf12;
}

Lorsque vous écrivez cette fonction en utilisant la technique que j'ai mentionnée, vous devez d'abord écrire la dernière ligne return hasExpectedPrefix && followedBy7Digits && hasLengthOf12;, puis écrire les 3 lignes qui la précèdent.

La technique la plus proche que j'ai pu trouver est le "vœu pieux" et c'est du SICP mais cela concerne les fonctions d'appel que vous allez implémenter plus tard plutôt que d'utiliser des variables que vous allez initialiser plus tard.

C'est juste une variation de la composition fonctionnelle.

Témoin:

private bool ValidPolicyNumber(string policyNumber) 
{
    return hasExpectedPrefix(policyNumber) 
        && followedBy7Digits(policyNumber) 
        && hasLengthOf12(policyNumber);
}

private bool hasExpectedPrefix(string policyNumber)
{
    return policyNumber.Substring(0,5) == "POLIC";
}

private bool followedBy7Digits
{
    return Regex.IsMatch(policyNumber.Substring(6,7), "^[0-9]{7}$");
}

private bool hasLengthOf12
{
    return policyNumber.Length == 12;
}

La seule vraie différence est que votre version combine les résultats calculés des petites fonctions dans une seule étendue fonctionnelle, ce que vous voulez, sauf si les petites expressions fonctionnelles sont destinées à être réutilisées ailleurs.

Cela pourrait simplement être une suggestion de Clean Code (le livre), à ​​utiliser lorsque la décomposition fonctionnelle (comme Robert l'a expliqué) n'est pas applicable car les fonctions résultant ne sont pas réutilisables par elles-mêmes.

Cependant, si vous voulez obtenir des détails techniques à ce sujet, le livre Implementation Patterns , de Kent Beck, nomme cette technique Explaining Local Variables (c'est moi qui souligne):

Variable locale

Les variables locales ne sont accessibles que de leur point de déclaration jusqu'à la fin de leur portée. En suivant le principe selon lequel les informations doivent se diffuser le moins possible, déclarez les variables locales juste avant leur utilisation et dans la portée la plus interne possible.

Il existe une poignée de rôles communs pour les variables locales:

• Collecteur: une variable qui recueille des informations pour une utilisation ultérieure. Souvent, le contenu des collecteurs est renvoyé comme la valeur d'une fonction. Lorsqu'un collecteur sera renvoyé, nommez-le résultat ou résultats.

• Count: un collecteur spécial qui recueille le nombre d'autres objets.

• Explication: si vous avez une expression compliquée, l'attribution de bits de l'expression à des variables locales peut aider les lecteurs à naviguer dans la complexité:

  int top = ...;

  int gauche = ...;

  int hauteur = ...;

  int bottom = ...;

  retourne un nouveau rectangle (haut, gauche, hauteur, largeur);

  Bien qu'elles ne soient pas nécessaires sur le plan du calcul, les variables locales explicatives aident ce qui autrement serait une expression longue et compliquée.