Java: refactoring/optimisation de code

Question

S'il vous plaît éclairer moi:

Lequel préférez-vous? Pourquoi? [Lisibilité? Problème de mémoire? D'autres questions?]

1.

String strSomething1 = someObject.getSomeProperties1(); 
strSomething1 = doSomeValidation(strSomething1); 
String strSomething2 = someObject.getSomeProperties2(); 
strSomething2 = doSomeValidation(strSomething2); 
String strSomeResult = strSomething1 + strSomething2; 
someObject.setSomeProperties(strSomeResult); 

2.

someObject.setSomeProperties(doSomeValidation(someObject.getSomeProperties1()) + 
          doSomeValidation(someObject.getSomeProperties2())); 

Si vous le faire d'une autre façon, ce que ce serait? Pourquoi ferais-tu ça?

Answer 1

Je serais probablement aller entre:

String strSomething1 = doSomeValidation(someObject.getSomeProperties1()); 
String strSomething2 = doSomeValidation(someObject.getSomeProperties2()); 
someObject.setSomeProperties(strSomething1 + strSomething2); 

Option # 2 semble beaucoup à faire en une seule ligne. C'est lisible, mais prend un peu d'effort pour analyser. Dans l'option # 1, chaque ligne est très lisible et claire dans l'intention, mais la verbosité me ralentit quand je la franchis. J'essayerais d'équilibrer brièveté et clarté comme ci-dessus, chaque ligne représentant une simple "phrase" de code.

Answer 2

Personnellement, je préfère le second. C'est moins encombré et je n'ai pas besoin de garder trace de ces variables temporaires. Cependant, cela peut changer facilement avec des expressions plus complexes.

Answer 3

je partirais avec:

String strSomething1 = someObject.getSomeProperties1(); 
String strSomething2 = someObject.getSomeProperties2(); 

// clean-up spaces 
strSomething1 = removeTrailingSpaces(strSomething1); 
strSomething2 = removeTrailingSpaces(strSomething2); 

someObject.setSomeProperties(strSomething1 + strSomething2); 

Ma préférence personnelle est d'organiser par l'action plutôt que la séquence. Je pense que ça se lit mieux.

Answer 4

Option 2 pour la lisibilité. Je ne vois pas de problèmes de mémoire ici si les méthodes ne font que ce que leurs noms indiquent. Je serais varier avec des concaténations cependant. La performance prend définitivement un rythme avec l'augmentation des concaves de cordes en raison de l'immuabilité de Java Strings. Juste curieux de savoir, avez-vous vraiment écrit votre propre méthode removeTrailingSpaces() ou est-ce juste un exemple?

Answer 5

Je préfère la seconde. Vous pouvez le rendre aussi lisible avec un peu de formatage, sans déclarer les références intermédiaires supplémentaires.

someObject.setSomeProperties(
    doSomeValidation(someObject.getSomeProperties1()) + 
    doSomeValidation(someObject.getSomeProperties2())); 

Vos noms de méthode fournissent toutes les explications nécessaires.

Answer 6

pour moi, cela dépend du contexte et du code environnant.

[EDIT: ne fait pas de sens, désolé] si elle était dans la méthode comme « setSomeObjectProperties() », je préfère la variante 2, mais aurais peut-être créer une méthode privée « getProperty (String name) » qui supprime les espaces de fuite si la suppression des espaces n'est pas une opération importante [/ EDIT]

Si la validation des propriétés est une étape importante de votre méthode, je dirais que la méthode « setValidatedProperties() » et préférerais une variante de votre première suggestion:

validatedProp1 = doValidation(someObject.getSomeProperty1()); 
validatedProp2 = doValidation(someObject.getSomeProperty2()); 
someObject.setSomeProperties(validatedProp1, validatedProp2); 

Si la validation n'est pas quelque chose d'important de cette méthode (par ex. J'aime essayer les propriétés qui ne sont pas validées), j'essaierais de mettre l'étape de validation dans "getSomePropertyX()"

Answer 7

J'aime les versions de Greg et Bill, je pense que j'écrirais plus naturellement du code comme celui de Greg un. Un avantage avec les variables intermédiaires: il est plus facile de déboguer (dans le cas général).

Answer 8

J'essaie d'avoir une opération par ligne. La raison principale est la suivante:

setX(getX().getY()+getA().getB()) 

Si vous avez un NPE ici, quelle méthode a retourné null? Donc, j'aime avoir des résultats intermédiaires dans une variable que je peux voir après que le code est tombé dans les bras forts du débogueur et sans avoir à redémarrer!