Dans MongoDB, les documents de la collection sont récupérés à l'aide de la méthode Find (), et les conditions peuvent être filtrées via des opérateurs de requête tels que $ eq, $ gt, $ lt, etc. 1. Utilisez $ eq ou spécifiez directement les paires de valeurs clés pour correspondre exactement, tels que db.users.find ({statut: "actif"}); 2. Utilisez des opérateurs de comparaison tels que $ gt et $ lt pour définir la plage numérique, telle que db.products.find ({prix: {$ gt: 100}}); 3. Utilisez des opérateurs logiques tels que $ ou et $ et pour combiner plusieurs conditions, telles que db.users.find ({$ ou: [{status: "inactive"}, {bancal: {$ gt: 1000}}]}); 4. Utilisez des paramètres de projection pour contr?ler le champ de retour, tels que db.users.find ({}, {nom: 1, e-mail: 1, _id: 0}) pour limiter la transmission des données pour améliorer les performances. Ces technologies offrent des capacités de requête flexibles et couvrent les cas d'utilisation les plus courants.

Dans MongoDB, la méthode find() est utilisée pour récupérer des documents d'une collection. Pour récupérer des documents spécifiques en fonction de certaines conditions, vous pouvez utiliser des opérateurs de requête comme $eq , $ne , $gt , $lt et d'autres directement dans la méthode find() .

Syntaxe de base de find()

La structure de base ressemble à ceci:

 db.collection.find (requête, projection)

• collection est le nom de votre collection.
• query est un objet qui définit les critères de recherche.
• projection (facultative) spécifie les champs à retourner.

Voyons maintenant comment utiliser efficacement divers opérateurs de requête avec find() .

Interroger des correspondances exactes avec $eq

Pour trouver des documents où un champ correspond exactement à une valeur spécifique, vous pouvez utiliser l'opérateur $eq ou simplement fournir directement la paire de valeurs clés directement.

Par exemple, si vous souhaitez trouver tous les utilisateurs dont status est "active" , vous pouvez écrire:

 db.users.find ({status: "actif"})

Cela fonctionne parce que lorsque vous spécifiez { status: "active" } , cela équivaut à l'utilisation $eq .

Si vous préférez être explicite, en particulier pour plus de clarté dans les requêtes complexes, vous pouvez également écrire:

 db.users.find ({status: {$ eq: "actif"}})

Ce style devient plus utile à mesure que vos requêtes se développent en complexité.

Filtrage avec les opérateurs de comparaison: $gt , $lt , etc.

Lorsque vous devez filtrer des documents basés sur des comparaisons numériques - comme plus que, moins que ou entre - les opérateurs de comparaison entrent en jeu.

Supposons que vous ayez une collection de produits et que vous souhaitez trouver des articles au prix de plus de 100:

 db.products.find ({prix: {$ gt: 100}})

Ou si vous voulez des prix entre 50 et 150:

 db.products.find ({prix: {$ gt: 50, $ lt: 150}})

Ces opérateurs vous permettent de définir des plages ou des seuils sans avoir besoin d'outils supplémentaires.

Certains opérateurs de comparaison couramment utilisés comprennent:

• $gt - supérieur à
• $gte - supérieur ou égal à
• $lt - moins que
• $lte - inférieur ou égal à
• $ne - pas égal à

Ils sont particulièrement utiles lorsqu'ils travaillent avec des données numériques ou basées sur des dates.

Utilisation des opérateurs logiques: $and , $or , $not

Parfois, votre requête doit combiner plusieurs conditions. Pour ces cas, les opérateurs logiques aident à structurer clairement la logique.

Par exemple, pour trouver des utilisateurs qui sont inactifs ou ont un solde supérieur à 1000:

 db.users.find ({
  $ ou: [
    {Status: "inactif"},
    {Balance: {$ gt: 1000}}
  ]]
})

Vous pouvez également utiliser $and (bien qu'il soit souvent implicite):

 db.users.find ({
  $ et: [
    {age: {$ gt: 25}},
    {statut: "actif"}
  ]]
})

Et si vous souhaitez exclure certaines valeurs, $not peut pas être utile:

 db.users.find ({age: {$ pas: {$ gt: 30}}})

Les opérateurs logiques facilitent l'exprimer des règles de filtrage complexes dans la syntaxe lisible de type JSON.

Projeter des champs spécifiques

Par défaut, find() renvoie tous les champs dans les documents correspondants. Mais si vous n'avez besoin que de certains champs, vous pouvez contr?ler ce qui est renvoyé à l'aide de la projection.

Dites que vous interrogez les données des utilisateurs, mais que vous avez seulement besoin de leurs noms et adresses e-mail:

 db.users.find ({}, {nom: 1, e-mail: 1, _id: 0})

Ici:

• 1 signifie inclure le champ
• 0 signifie l'exclure

Remarque: vous ne pouvez pas mélanger l'inclusion et l'exclusion, sauf si vous excluez _id .

Les projections aident à réduire le transfert de données inutile et à améliorer les performances, en particulier avec de grands documents.

L'utilisation de ces techniques vous offre beaucoup de flexibilité lors de l'interrogation des collections MongoDB. Que vous filtriez par des valeurs exactes, en comparant les nombres, en combinant des conditions ou en limitant la sortie, la méthode find() avec les opérateurs de requête couvre les cas d'utilisation les plus courants.

Fondamentalement, c'est tout.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!