Le code auto-documenté est plus facile à lire et à entretenir
Suivez le principe de la moindre expiation et du précepte du code en tant que documentation : utilisez une variable pour un objectif, à la fois pour rendre son utilisation facile à comprendre et le code facile à lire sans explications.
Un code correctement structuré est plus facile (donc moins cher) à (ré) utiliser
Ici aussi, il semblerait que ce query
soit toujours utilisé pour préparer une instruction avant de l'exécuter. C'est probablement un signe que vous souhaitez refactoriser une partie de ce code en une (ou plusieurs) méthodes d'assistance pour préparer et exécuter la requête (pour se conformer au principe DRY ).
De cette façon, vous pourrez efficacement:
- utilisez une seule variable dans votre méthode d'assistance pour identifier la requête du contexte actuel,
- besoin de taper moins de code à chaque fois que vous souhaitez réexécuter une requête,
- rendre votre code plus lisible pour les autres.
Exemples:
Considérez ceci, tiré de votre exemple, où la version refactorisée est évidemment meilleure. Bien sûr, votre extrait de code n'était qu'un exemple aux fins de cette question, mais le concept reste vrai et évolue.
Votre exemple 1:
Strings querycre,queryins,queryup,querydel;
querycre = 'Create table XYZ ...';
execute querycre ;
queryins = 'Insert into XYZ ...';
execute queryins ;
queryup = 'Update XYZ set ...';
execute queryup;
querydel = 'Delete from XYZ ...';
execute querydel ;
Votre exemple 2:
Strings query;
query= 'Create table XYZ ...';
execute query ;
query= 'Insert into XYZ ...';
execute query ;
query= 'Update XYZ set ...';
execute query ;
query= 'Delete from XYZ ...';
execute query ;
Exemple 3 (pseudo-code refactorisé):
def executeQuery(query, parameters...)
statement = prepareStatement(query, parameters);
execute statement;
end
// call point:
executeQuery('Create table XYZ ... ');
executeQuery('Insert into XYZ ...');
executeQuery('Update XYZ set ...');
executeQuery('Delete from XYZ ...');
L'avantage se manifeste par une réutilisation régulière.
Anecdote personnelle
J'ai d'abord commencé en tant que programmeur C travaillant avec un espace d'écran limité, donc la réutilisation des variables était logique à la fois pour le code compilé (à l'époque) et pour permettre à plus de code d'être lisible à la fois.
Cependant, après avoir évolué vers des langages de niveau supérieur et perfectionné la programmation fonctionnelle, j'ai pris l'habitude d'utiliser des variables immuables et des références immuables autant que possible pour limiter les effets secondaires.
Qu'est-ce qu'il y a pour moi?
Si vous prenez l'habitude d'avoir toutes les entrées de votre fonction immuables et de retourner un nouveau résultat (comme le ferait une vraie fonction mathématique), vous avez l'habitude de ne pas dupliquer les magasins.
Par extension, cela conduit à:
- vous écrivez de courtes fonctions,
- avec des objectifs bien définis,
- qui sont plus faciles à comprendre,
- réutilliser,
- d'étendre (que ce soit par héritage OO ou par chaînage fonctionnel),
- et documenter (comme déjà auto-documenté).
Je ne dis pas qu'il n'y a aucun avantage à l'état mutable ici, je souligne simplement comment l'habitude pourrait se développer sur vous et comment elle influe sur la lisibilité du code.