web-dev-qa-db-fra.com

Comment puis-je reformater ma condition pour le rendre meilleur?

J'ai une condition

if(exists && !isDirectory || !exists)
{}

comment puis-je le modifier, de sorte qu'il peut être plus compréhensible.

conditions
35
Spynet

|| Est commutative si

if(!exists || (exists && !isDirectory))

est équivalent.

Maintenant que cela existe est toujours vrai dans la deuxième partie du || Vous pouvez déposer le &&:

if(!exists || !isDirectory)

Ou vous pouvez aller plus loin et faire:

if(!(exists && isDirectory))
110
ratchet freak

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 à NAND Opération , qui est simplement:

!(exists && isDirectory)

Si vous ne vous souvenez pas de toutes vos portes logiques, Wikipedia a une belle référence avec les tables de vérité à démarrer .

@Christoffer Hammarström a élevé un point important sur l'état de isDirectory étant attaché à 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 est un répertoire, la vérité Le tableau peut être écrit 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. Des réductions acceptables pourraient entraîner une 1 Ou 0 Pour les états qui ont obtenu n/a.

Dans cet esprit, !(exists && isDirectory) est toujours une réduction valide, ce qui entraîne un 1 Pour !e && d.

Cependant, !isDirectory Serait une réduction beaucoup plus simple, ce qui permettrait de 0 Pour !e && d.

51
zzzzBov

Pour une meilleure lisibilité, j'aime 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 déterminer ce que signifie la condition booléenne.

22
Puckl

Vous pouvez utiliser une table de vérité comme indiquée. La deuxième étape pourrait être une kv-map pour minimiser le nombre de termes.

Utiliser les lois de algèbre booléen est une autre approche:

A = existe
B =! Isdirectory
[.____]! A =! Existe

&& = *
[.____] || = +

[modifier]
[.____] une transformation plus simple, car les opérations et OR sont distributives mutuellement:

existe &&! isdirectory || ! existe
[.____] = a * b +! Un
[.____] = (A +! A) * (B +! A)
[.____] = 1 * (B +! A)
[.____] = b +! Un
[/ EDIT]

existe &&! isdirectory || ! existe
[.____] = a * b +! Un
[.____] = a * b +! A * 1 // identité
[.____] = A * B +! A * (B + 1) // Annihilator
[.____] = A * B +! A * B +! A // Distribution et identité
[.____] = B * (A +! A) +! A // Distribution
[.____] = B * 1 +! A // Complemence 2
[.____] = B +! A // Identité
[.____] =! isdirectory || ! existe

Ou avec double complément (!! x = x):

A * b +! Un
[.____] = !! (a * b +! A)
[.____] =! (! (A * b) * a)
=! ((! A +! B) * a)
[.____] =! (! A * A +! B * a)
[.____] =! (0 +! B * a)
[.____] =! (! B * a)
[.____] = b +! Un
[.____] =! isdirectory || ! existe

6
Eddie Gasparian

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) 
   {}
5
David W