Fonctions booléennes

Les fonctions booléennes retournent true ou false. Elles sont essentielles pour vérifier des conditions et valider des données.

Vérification d'existence

valeur.exists()

Vérifie si une valeur existe et n'est pas nulle ou vide. C'est la fonction booléenne la plus utilisée.

JavaScript

"texte".exists() // true
"".exists()                                         // false
null.exists()                                       // false
0.exists()                                          // true (0 est une valeur valide)

// Vérifier si un champ optionnel est rempli
client.email.exists()                           // true si l'email est renseigné

// Vérifier si un tableau n'est pas vide
commande.produits.exists()                      // true si des produits existent

Bon à savoir : exists retourne truepour le nombre 0 et le booléen false. Elle vérifie seulement si la valeur est définie, pas si elle est "truthy".

Négation avec !

Utilisez ! devant existspour vérifier qu'une valeur n'existe pas.

JavaScript

!client.email.exists()                    // true si pas d'email

// Afficher un message si le champ est manquant
!client.telephone.exists()
? "Téléphone non renseigné"
: client.telephone

Vérification sur tableaux

Ces fonctions permettent de vérifier des conditions sur tous les éléments d'un tableau.

tableau.allEqual(valeur)

Vérifie si tous les éléments du tableau sont égaux à la valeur.

JavaScript

[1, 1, 1].allEqual(1) // true
[1, 2, 1].allEqual(1)                                    // false (2 n'est pas égal à 1)

// Vérifier si toutes les commandes sont validées
client.commandes.statut.allEqual("validée")

// Vérifier si tous les produits sont en stock
commande.produits.map(x => x.stock > 0).allEqual(true
)

tableau.anyEqual(condition)

Vérifie si au moins un élément satisfait la condition. Le paramètre de la lambda nomme l'élément courant : l => l.champ.

JavaScript

                     // Vérifier si au moins une valeur correspond
["créé", "soldé", "annulé"].anyEqual(x => x === "soldé") // true

// Vérifier si au moins un produit est en rupture
commande.produits.anyEqual(x => x.stock === 0)

// Vérifier si au moins une facture est impayée
client.factures.anyEqual(x => x.payee === false)

Astuce : Cette fonction est l'équivalent d'un "OU logique" appliqué à tous les éléments. Si un seul satisfait la condition, elle retourne true.

tableau.noneEqual(condition)

Vérifie qu'aucun élément ne satisfait la condition. C'est l'inverse de anyEqual.

JavaScript

                       // Vérifier qu'aucun statut n'est "annulé"
["Créé", "Validé", "Soldé"].noneEqual(x => x === "Annulé") // true

// Vérifier qu'aucun produit n'est en rupture
commande.produits.noneEqual(x => x.stock === 0)

// Vérifier qu'aucune tâche n'est en retard
projet.taches.noneEqual(x => x.dateEcheance < today())

Comparaison des trois fonctions

`allEqual`	→ Tous les éléments doivent correspondre
`anyEqual`	→ Un seul élément suffit
`noneEqual`	→ Aucun élément ne doit correspondre

Combiner les vérifications

Vous pouvez combiner les fonctions booléennes avec les opérateurs logiques&&, || et !.

JavaScript

// Vérifier plusieurs conditions
client.email.exists() && client.telephone.exists()

// Vérifier qu'au moins un moyen de contact existe
client.email.exists() || client.telephone.exists()

// Condition complexe
commande.exists()
&& commande.produits.disponible.allEqual(true)
&& commande.produits.stock.noneEqual(0)

Exemples pratiques

Valider un formulaire client

JavaScript

let emailValide = client.email.exists();
let telephoneValide = client.telephone.exists()
  && client.telephone.count() === 10;
let siretValide = client.siret.exists()
  && client.siret.count() === 14;

emailValide && telephoneValide && siretValide
? "✓ Fiche complète"
: "⚠ Informations manquantes"

Vérifier si une commande peut être expédiée

JavaScript

let tousEnStock = commande.produits.noneEqual(produit => produit.stock < produit.quantite);
let adresseComplete = commande.adresseLivraison.exists();
let paiementValide = commande.paiement.statut === "validé";

tousEnStock && adresseComplete && paiementValide
? "Prêt pour expédition"
:
  !tousEnStock ? "Stock insuffisant"
  : !adresseComplete ? "Adresse manquante"
  : "Paiement en attente"

Afficher une valeur ou un texte par défaut

JavaScript

// Méthode simple
client.email.exists()
? client.email
: "Non renseigné"

// Avec plusieurs champs
client.portable.exists()
? client.portable
: client.fixe.exists()
? client.fixe
: "Aucun téléphone"

Vérifier l'état d'un projet

JavaScript

let taches = projet.taches;
let toutesTerminees = projet.taches.map(tache => tache.statut).allEqual("terminée");
let auMoinsUneEnRetard = projet.taches.anyEqual(tache => tache.dateEcheance < today() && tache.statut !== "terminée"
);

toutesTerminees
? "✓ Projet terminé"
: auMoinsUneEnRetard
? "⚠ Projet en retard"
: "⏳ Projet en cours"

Contrôle d'unicité d'email

JavaScript

let email = nouveauClient.email;
let clientExistant = findObject(client, { email: email });

clientExistant.exists()
? "⚠ Cet email est déjà utilisé"
: "✓ Email disponible"

Prochaine étape

Apprenez maintenant à rechercher des objets dans votre base de données avec les fonctions d'accès aux données.

Accès aux données →← Fonctions de texte