MongoDB Academy · Leçon

Opérateurs d’élément et vérifications de type

Vous rechercherez la présence ou le type d’un champ avec $exists et $type afin de gérer des données facultatives ou de types mixtes.

Leçon 3 sur 413 étapes

Opérateurs d’élément et vérifications de type est une leçon MongoDB Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage MongoDB Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours MongoDB Academy comprend 4 leçons au total.

Champs facultatifs dans les schémas flexibles

Le schéma flexible de MongoDB signifie que certains documents d’une collection peuvent contenir des champs absents d’autres documents. Un document utilisateur peut comporter un champ phoneNumber facultatif : certains utilisateurs l’ont renseigné, d’autres non. En SQL, vous géreriez cette situation avec une valeur NULL dans chaque ligne. Dans MongoDB, le champ n’existe tout simplement pas dans certains documents.

Cette différence a des conséquences importantes pour les requêtes. Les opérateurs d’élément de MongoDB — principalement $exists et $type — vous permettent d’interroger les documents selon la présence ou le type d’un champ, plutôt que selon sa valeur.

$exists : vérifier la présence d’un champ

$exists: true correspond aux documents qui contiennent le champ indiqué, quelle que soit sa valeur, même si celle-ci est null. $exists: false correspond aux documents dans lesquels le champ est totalement absent.

Cette distinction est subtile, mais importante : un document contenant { phone: null } correspond bien à { phone: { $exists: true } }, car le champ existe — sa valeur est simplement nulle. Seul un document ne contenant aucun champ phone correspond à { phone: { $exists: false } }.

// Find users who have provided a phone number (field exists)
db.users.find({ phone: { $exists: true } });

// Find users who never provided a phone number (field absent)
db.users.find({ phone: { $exists: false } });

// Key distinction:
// { phone: null }    => $exists: true (field exists, value is null)
// { name: 'Alice' }  => $exists: false (no phone field at all)

// Combined: field exists AND is not null
db.users.find({ phone: { $exists: true, $ne: null } });

Requêtes sur null et les champs absents

Le filtre d’égalité de MongoDB avec null a un double comportement qui surprend souvent les débutants : { phone: null } correspond aux documents dans lesquels phone vaut explicitement null et aux documents dans lesquels phone n’existe pas du tout. Cela s’explique par le fait que MongoDB considère implicitement un champ absent comme nul lors des comparaisons d’égalité.

Si vous souhaitez distinguer « le champ vaut null » de « le champ est absent », combinez $exists avec $eq: null. Dans la plupart des cas pratiques, ces deux situations signifient « aucun numéro de téléphone fourni » et vous pouvez les traiter de la même manière.

// Matches BOTH null and missing field:
db.users.find({ phone: null });
// Returns: { name: 'Alice', phone: null }
//      AND: { name: 'Bob' }  (no phone field)

// Only where field is explicitly null:
db.users.find({ phone: { $eq: null, $exists: true } });
// Returns: { name: 'Alice', phone: null }
// NOT: { name: 'Bob' } (missing field)

// Only where field is missing:
db.users.find({ phone: { $exists: false } });

$type : interroger selon le type BSON

MongoDB permet d’utiliser des schémas flexibles, ce qui signifie qu’un champ comme price peut être un Number dans la plupart des documents, mais avoir été enregistré par erreur comme une String dans certains anciens enregistrements. L’opérateur $type vous permet de filtrer les documents selon le type BSON de la valeur d’un champ.

Vous pouvez indiquer les types par leur nom (par exemple 'string', 'int', 'date') ou par leur numéro de type BSON (par exemple 2 pour String, 16 pour Int32). L’utilisation des noms de types est plus lisible et préférable.

// Find documents where price is a string (data quality issue)
db.products.find({ price: { $type: 'string' } });
// These need to be fixed - price should be a number

// Find documents where price is a number (any numeric type)
db.products.find({ price: { $type: ['double', 'int', 'long', 'decimal'] } });
// $type accepts an array - matches any of the listed types

// Check for boolean
db.settings.find({ enabled: { $type: 'bool' } });

Noms de types BSON courants

Les noms de types BSON les plus utilisés dans les requêtes $type sont les suivants :

'double' — nombre à virgule flottante sur 64 bits (nombre par défaut de JS)
'string' — chaîne UTF-8
'object' — document intégré (sous-objet)
'array' — tableau
'binData' — données binaires
'objectId' — ObjectId
'bool' — booléen
'date' — date
'null' — valeur nulle
'int' — entier sur 32 bits
'long' — entier sur 64 bits
'decimal' — Decimal128

// Real-world use: find documents where tags is an array
db.products.find({ tags: { $type: 'array' } });

// Find docs where createdAt is a date (not a string)
db.events.find({ createdAt: { $type: 'date' } });

// Audit: find any document where _id is not an ObjectId
db.users.find({ _id: { $not: { $type: 'objectId' } } });
// These might be docs with custom string _ids

L’alias « number »

Un raccourci utile est l’alias de type 'number', qui correspond à tous les types BSON numériques : double, int, long et decimal. Cela revient à écrire un tableau contenant les quatre noms de types numériques, mais de façon beaucoup plus claire.

Utilisez 'number' lorsque vous souhaitez trouver tous les documents dans lesquels un champ est un nombre, quel que soit le niveau de précision utilisé. Cela est particulièrement utile pour les contrôles de qualité des données lorsque vous voulez repérer les champs qui devraient être numériques, mais qui ont été enregistrés par erreur sous forme de chaînes.

// 'number' alias matches double, int, long, decimal
db.products.find({ price: { $type: 'number' } });
// Same as: { price: { $type: ['double', 'int', 'long', 'decimal'] } }

// Data quality check: find price fields that are strings
// These should be numbers:
db.products.find({ price: { $type: 'string' } });

// Fix those docs:
db.products.find({ price: { $type: 'string' } }).forEach(doc => {
  db.products.updateOne(
    { _id: doc._id },
    { $set: { price: parseFloat(doc.price) } }
  );
});

Utiliser $exists dans les migrations de schéma

Les migrations de schéma dans MongoDB consistent souvent à ajouter de nouveaux champs obligatoires aux documents existants. $exists vous aide à trouver les documents qui doivent encore être mis à jour — ou ceux qui ont déjà été migrés.

Un processus de migration courant consiste d’abord à utiliser { newField: { $exists: false } } pour trouver tous les anciens documents, puis à ajouter le nouveau champ avec une valeur par défaut. Suivez l’avancement en comptant le nombre de documents qui présentent encore $exists: false. Cette approche de migration progressive fonctionne sans interruption de service, car le schéma flexible de MongoDB permet temporairement aux anciennes et aux nouvelles structures de documents de coexister.

// Migration: add 'timezone' field with default value to legacy users
async function migrateTimezone() {
  const batchSize = 1000;
  let processed = 0;

  while (true) {
    const result = await db.collection('users').updateMany(
      { timezone: { $exists: false } },  // Legacy docs without field
      { $set: { timezone: 'UTC' } },     // Add default
      { limit: batchSize }               // Process in batches
    );
    processed += result.modifiedCount;
    if (result.modifiedCount === 0) break;
  }
  console.log('Migrated:', processed);
}

Combiner $exists et $type

Vous pouvez combiner $exists et $type dans une seule requête pour trouver les documents dans lesquels un champ existe et possède un type précis. Cela est utile lors des audits de qualité des données, lorsque vous souhaitez distinguer les documents dans lesquels le champ possède un type incorrect de ceux dans lesquels il est simplement absent.

Par exemple, dans une collection où age devrait être un nombre, vous pouvez compter séparément : (1) les documents où le champ age est totalement absent, (2) les documents où age est une chaîne (erreur de saisie) et (3) les documents où age est un nombre valide.

// Audit 'age' field data quality
const total = await db.collection('users').countDocuments({});

const missingAge = await db.collection('users')
  .countDocuments({ age: { $exists: false } });

const ageIsString = await db.collection('users')
  .countDocuments({ age: { $type: 'string' } });

const ageIsNumber = await db.collection('users')
  .countDocuments({ age: { $type: 'number' } });

console.log(`Total: ${total}, Missing: ${missingAge}, String: ${ageIsString}, Number: ${ageIsNumber}`);

$expr : comparaisons entre champs

L’opérateur $expr vous permet d’utiliser des expressions d’agrégation dans un filtre find() standard. Cela permet d’effectuer des comparaisons entre champs, ce qui est impossible avec les opérateurs de requête standard.

Par exemple, « trouver les commandes dont la remise est supérieure à 50 % du prix d’origine » nécessite de comparer discount à une fraction calculée de originalPrice — deux champs du même document. $expr permet ces relations à l’aide d’opérateurs d’expression comme $gt, $multiply et $divide.

// Find products where salePrice < originalPrice * 0.7 (>30% off)
db.products.find({
  $expr: {
    $lt: [
      '$salePrice',
      { $multiply: ['$originalPrice', 0.7] }
    ]
  }
});

// Find orders where quantity ordered > quantity in stock
db.orders.find({
  $expr: { $gt: ['$quantityOrdered', '$quantityInStock'] }
});

Indexer les requêtes avec $exists

Les requêtes utilisant $exists bénéficient de façon variable de la prise en charge des index. Un index sur un champ n’aide pas pour { field: { $exists: false } } : si le champ est absent, il ne figure pas dans l’index, et MongoDB doit donc analyser chaque document. En revanche, { field: { $exists: true } } peut utiliser un index partiel : un index partiel n’enregistre que les entrées des documents qui possèdent le champ indexé, ce qui permet de retrouver rapidement les documents concernés.

Utilisez db.collection.createIndex({ field: 1 }, { sparse: true }) pour créer un index partiel lorsque vous interrogez fréquemment les documents qui possèdent un champ facultatif.

// Sparse index: only indexes docs where 'proSubscriptionId' exists
db.users.createIndex(
  { proSubscriptionId: 1 },
  { sparse: true }
);

// This query now uses the sparse index efficiently:
db.users.find({ proSubscriptionId: { $exists: true } });
// Only pro subscribers are in the index

// Regular (non-sparse) index would include null entries for all users
// Sparse index is smaller and faster for optional-field queries

Processus d’audit de la qualité des données

Un processus pratique d’audit de la qualité des données utilisant et consiste d’abord à identifier tous les modèles distincts de champs dans votre collection afin de repérer les incohérences, puis à classer les documents selon leurs types de champs et, enfin, à rédiger des appels ciblés à updateMany pour normaliser les données.

La chaîne d’agrégation de MongoDB facilite l’audit : par d’un champ afin de compter le nombre de documents correspondant à chaque type. Vous obtenez ainsi une vision claire des problèmes de qualité des données avant de commencer à les corriger.

// Audit: how many docs have price as each type?
db.products.aggregate([
  {
    : {
      _id: { : '' },  // Group by BSON type of price
      count: { : 1 }
    }
  }
]);
// Results like:
// [{ _id: 'double', count: 4820 },
//  { _id: 'string', count: 3 },
//  { _id: 'missing', count: 12 }]
// Now you know exactly what to fix!

Vérification rapide

Vérifiez votre compréhension des concepts de MongoDB et des bases de données NoSQL abordés dans cette leçon.

Réponds-y dans la leçon interactive

Récapitulatif de la leçon

Dans cette leçon, vous avez appris que les requêtes $exists vérifient la présence ou l'absence d'un champ — un champ manquant et un champ null sont différents et peuvent être distingués en combinant $exists: true avec $ne: null —, que $type filtre selon le nom du type BSON (chaîne, nombre, date, tableau, etc.) et est essentiel pour les audits de qualité des données dans les collections au schéma flexible, et que les index clairsemés prennent efficacement en charge les requêtes $exists: true sur les champs facultatifs en indexant uniquement les documents qui possèdent le champ. Ensuite, nous explorerons les requêtes avec des expressions régulières et la recherche de motifs pour effectuer des recherches textuelles flexibles.

Gratuit pour commencer

Apprends JavaScript avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 30
Leçons: 120

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Opérateurs d’élément et vérifications de type » est-elle gratuite ?

Oui — le texte complet de « Opérateurs d’élément et vérifications de type » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours MongoDB Academy, passe à CoddyKit PRO. Le cours MongoDB Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Opérateurs d’élément et vérifications de type » ?

Vous rechercherez la présence ou le type d’un champ avec $exists et $type afin de gérer des données facultatives ou de types mixtes. Tu pratiques MongoDB Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer MongoDB Academy ?

Aucune expérience préalable n'est requise. MongoDB Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Opérateurs d’élément et vérifications de type » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon MongoDB Academy ?

Oui. Chaque leçon MongoDB Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Opérateurs de comparaison : $eq, $gt, $lt, $in
Opérateurs logiques : $and, $or, $nor, $not
Opérateurs d’élément et vérifications de type
Requêtes avec expressions régulières et recherche de motifs

← Retour à MongoDB Academy