J'ai une condition
if(exists && !isDirectory || !exists)
{}
Comment puis-je le modifier pour qu'il soit plus compréhensible?
exists
et isDirectory
sont les deux vrais?
J'ai une condition
if(exists && !isDirectory || !exists)
{}
Comment puis-je le modifier pour qu'il soit plus compréhensible?
exists
et isDirectory
sont les deux vrais?
Réponses:
||
est si commutatif
if(!exists || (exists && !isDirectory))
est équivalent.
Maintenant, car existe est toujours vrai dans la deuxième partie de la, ||
vous pouvez laisser tomber le &&
:
if(!exists || !isDirectory)
Ou vous pouvez aller plus loin et faire:
if(!(exists && isDirectory))
&&
priorité est plus grande (du moins dans les langues les plus connues - il peut y avoir des exceptions) ||
. Ainsi a && b || c
est équivalent à (a && b) || c
mais pas à a && (b || c)
.
!exists || !isDirectory
c'est plus "compréhensible", parce que, isDirectory
ne peut être vrai si !exists
. Donc, en tant qu'être humain, nous dirons "s'il n'existe pas ou s'il [existe et que ce n'est pas un répertoire".
||
est uniquement commutatif si elle est utilisée sur des valeurs sans effets secondaires - si, par exemple, elle est utilisée avec des fonctions, certaines fonctions peuvent ne pas être appelées (court-circuit) ou renvoyer une valeur différente dans un ordre différent.
En tant que processus, je suggère de construire une table de vérité:
e = exists
d = isDirectory
e | d | (e && !d) || !e
--+---+----------------
0 | 0 | 1
0 | 1 | 1
1 | 0 | 1
1 | 1 | 0
Cela correspond à l' NAND
opération , qui est simplement:
!(exists && isDirectory)
Si vous ne vous souvenez pas de toutes vos portes logiques, Wikipedia a une bonne référence avec les tables de vérité à démarrer .
@Christoffer Hammarström a soulevé un point important à propos de l’état d’ isDirectory
être lié à l’état de exists
. En supposant qu'ils se réfèrent à la même référence et qu'il n'est pas possible d'avoir un état où la référence n'existe pas et constitue un répertoire, la table de vérité peut être écrite comme suit:
e | d | (e && !d) || !e
--+---+----------------
0 | 0 | 1
0 | 1 | n/a
1 | 0 | 1
1 | 1 | 0
Le n/a
est utilisé pour représenter un état qui n'a pas d'importance. Réductions acceptables pourraient entraîner soit 1
ou 0
les états résultant en n/a
.
Dans cet esprit, !(exists && isDirectory)
est toujours une réduction valide, entraînant un 1
pour !e && d
.
Cependant, !isDirectory
serait une réduction beaucoup plus simple, ce qui 0
pour !e && d
.
isDirectory
dépend exists
. Il ne peut pas être à la fois un répertoire et ne pas exister.
n/a
endroits où l'état est impossible à atteindre et l'équation doit être réduite en conséquence.
Pour une meilleure lisibilité, j'aime bien extraire des conditions booléennes aux méthodes:
if(fileNameUnused())
{...}
public boolean fileNameUnused() {
return exists && !isDirectory || !exists;
}
Ou avec un meilleur nom de méthode. Si vous pouvez nommer cette méthode correctement, le lecteur de votre code n’a pas besoin de comprendre ce que signifie la condition booléenne.
boolean fileNameUnused = !exists || !isDirectory; if (fileNameUnused) { doSomething(); }
Vous pouvez simplement essayer de résoudre le problème du non-départ et de renflouer si cela se présente.
while(someCondition) {
if(exists && isDirectory)
continue;
// maybe "break", depends on what you're after.
// the rest of the code
}
ou même
function processFile(someFile)
{
// ...
if(exists && isDirectory)
return false;
// the rest of the code
// ...
}
Vous pouvez utiliser une table de vérité comme indiqué. La deuxième étape pourrait être une carte KV pour minimiser le nombre de termes.
Utiliser les lois de l’algèbre booléenne est une autre approche:
A = existe
B =! IsDirectory
! A =! Existe
&& = *
|| = +
[Edit]
Une transformation plus simple, car les opérations AND et OR sont mutuellement distributives:
existe &&! isDirectory || ! existe
= A * B +! A
= (A +! A) * (B +! A)
= 1 * (B +! A)
= B +! A
[/ Modifier]
existe &&! isDirectory || ! existe
= A * B +! A
= A * B +! A * 1 // Identité
= A * B +! A * (B + 1) // Annihilateur
= A * B +! A * B +! A / / Distributivité et identité
= B * (A +! A) +! A // Distributivité
= B * 1 +! A // Complémentation 2
= B +! A // Identité
=! IsDirectory || ! existe
Ou avec double complément (!! x = x):
A * B +! A
= !! (A * B +! A)
=! (! (A * B) * A)
=! ((! A +! B) * A)
=! (! A * A + ! B * A)
=! (0 +! B * A)
=! (! B * A)
= B +! A
=! IsDirectory || ! existe
Je n'aime pas utiliser "!" quand il y a plus d'une condition dans l'expression. Je vais ajouter des lignes de code pour le rendre plus lisible.
doesNotExist = !exists;
isFile = exists && !isDirecotry;
if (isFile || doesNotExist)
{}
Comme indiqué précédemment, la condition peut être réduite à:
if (!(exists && isDirectory))
Cependant, je parie qu'être un répertoire implique l'existence. Si tel est le cas, nous pouvons réduire la situation à:
if (!isDirectory)