Comment puis-je reformater ma condition pour l'améliorer?

J'ai une condition

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

Comment puis-je le modifier pour qu'il soit plus compréhensible?

|| 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))

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' NANDopé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/aest utilisé pour représenter un état qui n'a pas d'importance. Réductions acceptables pourraient entraîner soit 1ou 0les états résultant en n/a.

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

Cependant, !isDirectoryserait une réduction beaucoup plus simple, ce qui 0pour !e && d.

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.

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)