Utilisez-vous à la StringUtils.EMPTY
place de ""
?
Je veux dire soit comme valeur de retour, soit si vous définissez la valeur d'une variable String. Je ne veux pas faire de comparaison, car là on utiliseStringUtils.isEmpty()
Réponses:
Bien sûr que non. Pensez-vous vraiment que "" n'est pas assez clair?
Les constantes ont essentiellement 3 cas d'utilisation:
Aucun ne s'applique ici.
EMPTY
n'a aucune signification que la chaîne vide elle-même n'a pas déjà. Plus particulièrement, il ne documente pas pourquoi vous avez décidé d'utiliser une chaîne vide dans ce cas particulier. Ce n'est pas différent de nommer une constante ONE
et de prétendre qu'il était utile d'utiliser cette constante au lieu de la valeur.
J'utilise StringUtils.EMPTY
, pour cacher le littéral et aussi pour exprimer ce qui return StringUtils.EMPTY
était pleinement attendu et qu'il devrait renvoyer une chaîne vide, ""
peut conduire à l'hypothèse qui ""
peut être facilement changée en autre chose et que ce n'était peut-être qu'une erreur. Je pense que EMPTY
c'est plus expressif.
StringUtils.EMPTY
moins expressif que ""
.
""
c'est plus expressif que d'utiliser StringUtils.EMPTY
, et ce que vous avez dit n'a pas changé d'avis à ce sujet. Je peux à peu près croire que les développeurs ont mal écrit une chaîne vide littéralement très, très occasionnellement - mais je prendrai la clarté de la chaîne littérale sur une fois dans un million (et facilement trouvée dans les tests, espérons-le ... ) bug, personnellement.
Non, utilisez simplement ""
.
Le littéral ""
est clair comme du cristal. Il n'y a pas de malentendu sur ce que cela voulait dire. Je ne saurais pas pourquoi vous auriez besoin d'une constante de classe pour cela. Je ne peux que supposer que cette constante est utilisée dans tout le package contenant StringUtils
au lieu de ""
. Cela ne signifie pas pour autant que vous devriez l'utiliser.
S'il y a un rocher sur le trottoir, vous n'êtes pas obligé de le lancer.
Je suis étonné de voir combien de personnes sont heureuses de supposer aveuglément que "" est en effet une chaîne vide et ne contient (accidentellement?) Aucun des merveilleux caractères invisibles et non espacés d'Unicode. Pour l'amour de tout ce qui est bon et décent, utilisez VIDE chaque fois que vous le pouvez.
J'ajouterai mes deux cents ici car je ne vois personne parler de String
stage et d'initialisation de classe:
String
littéraux dans les sources Java sont internées, ce qui rend tout ""
et StringUtils.EMPTY
le même objetStringUtils.EMPTY
peut initialiser la StringUtils
classe, car elle n'accède à son membre statique EMPTY
que s'il n'est pas déclaréfinal
(le JLS est spécifique sur ce point). Cependant, c'est définitif, donc il n'initialisera pas la classe.org.apache.commons.lang3.StringUtils.EMPTY
Voir une réponse connexe sur l'internement de chaînes et sur l' initialisation de classe , se référant au JLS 12.4.1 .
StringUtils
classe.
Je n'aime pas vraiment l'utiliser, car return "";
c'est plus court que return StringUtils.EMPTY
.
Cependant, un faux avantage de son utilisation est que si vous tapez return " ";
au lieu de return "";
, vous pouvez rencontrer un comportement différent (si vous testez correctement une chaîne vide ou non).
""
plus, je déteste taper la même chaîne littérale plus d'une fois, même une seule fois parfois. Je préfère déclarer les constantes dans Constants.java , mais ne pas les répéter partout dans le code source.
return "";
c'est moche, je préfère utiliser return StringUtil.EMPTY
(déclaré dans ma propre classe StringUtil , PAS StringUtils d'Apache ).
Si votre classe n'utilise rien d'autre des communs, il serait dommage d'avoir cette dépendance uniquement pour cette valeur magique.
Le concepteur de StringUtils fait un usage intensif de cette constante, et c'est la bonne chose à faire, mais cela ne signifie pas que vous devez également l'utiliser.
Honnêtement, je ne vois pas grand-chose à utiliser. Si vous voulez comparer par exemple une chaîne vide, utilisez simplementStringUtils.isNotEmpty(..)
StringUtils.isNotEmpty(..)
fait également un contrôle nul, donc ce n'est pas exactement la même chose que la comparaison avec une chaîne vide.
null
? comme deuxième argument de equals
, mais le résultat sera le même -false
isNotEmpty
est l'opposé de "".equals(…)
, par conséquent, le fait qu'il traitera null
comme une chaîne vide est différent de comparer avec une chaîne vide, "".equals("")
→ true
, "".equals(null)
→ false
, StringUtils.isNotEmpty("")
→ false
, StringUtils.isNotEmpty(null)
→ false
. Si vous voulez juste savoir si une chaîne est vide, utilisez string.isEmpty()
, qui a le bon comportement de retour true
si c'est une chaîne vide et de lancer un NullPointerException
si la chaîne est null
…
Je trouve StringUtils.EMPTY
utile dans certains cas pour la lisibilité. Particulièrement avec:
Opérateur ternaire, par exemple.
item.getId() != null ? item.getId() : StringUtils.EMPTY;
En utilisant également une constante, une référence à StringUtils.EMPTY
est créée. Sinon, si vous essayez d'instancier le littéral String à ""
chaque fois, la JVM devra vérifier s'il existe déjà dans le pool String (ce qui sera probablement le cas, donc pas de surcharge de création d'instance supplémentaire). L'utilisation StringUtils.EMPTY
évite sûrement la nécessité de vérifier le pool de chaînes?
StringUtils.EMPTY
constante est résolue au moment de la compilation.
StringUtil.EMPTY
s'agit d'une constante de compilation, une référence à celle-ci est compilée exactement avec le même bytecode que l'utilisation ""
directe. De plus, je ne vois pas pourquoi l'opérateur ternaire devrait faire une différence. C'est une expression comme les autres. Toute raison d'utiliser ou de ne pas utiliser une constante nommée s'applique également à l'opérateur ternaire.
Non, car j'ai plus à écrire. Et une chaîne vide est vide indépendante de la plate-forme (en Java).
File.separator
est meilleur que "/" ou "\".
Mais fais comme tu veux. Vous ne pouvez pas obtenir une faute de frappe commereturn " ";
someString.isEmpty()
place.
Oui, cela a du sens. Ce n'est peut-être pas la seule façon de procéder, mais je ne vois pas grand-chose à dire que «cela n'a pas de sens».
À mon avis:
It will still require changing everywhere if you don't define your own variable and use it in multiple places.
vous allez changer une chaîne vide en une chaîne vide différente?
StringUtils.EMPTY
. Cela montre clairement que l'utilisation de la chaîne vide est prévue, et non une sorte de paresse ("Oh, cela nécessite une chaîne, passons""
"). Si quelqu'un frappe ce morceau de code, il réfléchira à deux fois avant d'apporter des modifications. De plus, siStringUtils.EMPTY
était défini comme votre propre variable, commeMyClass.EMPTY
, apporter des modifications à «cette représentation de la vacuité» nécessiterait de changer une ligne de code. Vous pouvez, par exemple, le remplacer par une"<empty>"
chaîne vide""
. Mais je pense que cela va un peu trop loin.