MongoDB trouver()

Dans MongoDB, le db.collection.find() méthode sélectionne des documents dans une collection ou une vue et renvoie un curseur sur les documents sélectionnés.

La collection part est le nom de la collection ou de la vue à rechercher.

Vous pouvez l'utiliser pour renvoyer tous les documents, seulement certains ou un seul document. Vous pouvez également spécifier les champs à renvoyer.

Il est important de noter qu'il ne renvoie pas réellement les documents. Il renvoie simplement un curseur aux documents. Cela dit, il est plus facile de dire qu'il "renvoie des documents", et il est généralement mentionné de cette manière - y compris dans cet article 🙂

Renvoyer tous les documents

Voici un exemple pour illustrer.

db.pets.find() 

Résultat :

{ "_id" :1, "name" :"Wag", "type" :"Chien", "weight" :20 }{ "_id" :2, "name" :"Bark", "type" :"Chien", "poids" :10 }{ "_id" :3, "nom" :"Miaou", "type" :"Chat", "poids" :7 }{ "_id" :4, "nom" :"Scratch", "type" :"Cat", "weight" :8 }{ "_id" :5, "name" :"Bruce", "type" :"Bat", "weight" :3 } 

 Ici, nous utilisons le find() méthode pour renvoyer tous les documents de pets le recueil. Nous savons que cela renvoie tous les documents car nous n'avons fourni aucun critère de filtrage. En fait, nous n'avons fourni aucun argument.
 

 Lorsqu'il est appelé sans arguments, find() renvoie tous les documents d'une collection et renvoie tous les champs des documents.
 

 Voici une autre façon de faire ce qui précède :
 
db.pets.find({}) 
 

 Dans ce cas, nous passons un document vide. 
 

 En ajoutant à ce document vide, nous pouvons commencer à filtrer les résultats.
 
Filtrer les résultats
 

 La syntaxe réelle de find() va comme ceci :
 
db.collection.find(query, projection) 
 

 Cela signifie que vous pouvez passer une requête en premier argument et une projection en second.
 

 Si vous transmettez une requête, elle est utilisée pour filtrer les résultats. Une requête est un document qui contient des opérateurs de requête. Comme nous l'avons vu dans l'exemple précédent, un document vide renvoie tous les documents.
 

 Limitons les résultats à un sous-ensemble de documents de la collection.
 
db.pets.find({"type":"Dog"}) 
 

 Résultat :
 
{ "_id" :1, "name" :"Wag", "type" :"Chien", "weight" :20 }{ "_id" :2, "name" :"Bark", "type" :"Chien", "poids" :10 }
 

 Cela a réduit les résultats aux seuls documents qui ont un type champ avec une valeur de Dog .
 

 Dans ce cas, nous avons simplement passé un document comme critère de filtrage.
 

 Vous pouvez également utiliser des opérateurs de requête. Ceux-ci vous permettent d'appliquer des critères plus spécifiques à votre requête. 
 

 Exemple :
 
db.pets.find({"weight": { $lt: 10 }}) 
 

 Résultat :
 
{ "_id" :3, "name" :"Meow", "type" :"Chat", "weight" :7 }{ "_id" :4, "name" :"Scratch", "type" :"Chat", "poids" :8 }{ "_id" :5, "nom" :"Bruce", "type" :"Chauve-souris", "poids" :3 }
 
Documents intégrés
 

 Si vous avez des documents qui contiennent des documents incorporés, vous pouvez utiliser les méthodes suivantes pour interroger les données dans les documents incorporés.
 
 
Notation par points (par exemple, field.nestedfield: <value> )
 
Formulaire imbriqué (par exemple, { field: { nestedfield: <value> } } ). Notez que cette option n'est disponible qu'à partir de MongoDB 4.4.
 
 

 Supposons que nous insérions le document suivant.
 
db.pets.insertOne({ "_id" :6, "name" :"Fetch", "type" :"Chien", "specs" :{ "height" :400, "weight" :15, " couleur" :"marron" }})
 

 Nous pouvons utiliser la notation par points pour interroger dans le document intégré.
 
db.pets.find({ "specs.height": 400 }) 
 

 Résultat :
 
{ "_id" :6, "name" :"Fetch", "type" :"Chien", "specs" :{ "height" :400, "weight" :15, "color" :"brown" } }
 

 La requête suivante renvoie le même document, sauf que cette fois nous référençons le document intégré à l'aide d'un formulaire imbriqué.
 
db.pets.find({ 
    "specs" : {
		"height" : 400,
		"weight" : 15,
		"color" : "brown"
	}
 }) 
 

 Résultat :
 
{ "_id" :6, "name" :"Fetch", "type" :"Chien", "specs" :{ "height" :400, "weight" :15, "color" :"brown" } }
 

 Lors de l'utilisation du formulaire imbriqué, la requête doit correspondre exactement à l'ensemble du document intégré. Par exemple, la requête suivante ne correspond pas :
 
db.pets.find({ 
    "specs" : {
		"height" : 400
	}
 }) 
 
Formater les résultats
 

 Le résultat de l'exemple précédent a été renvoyé sur une seule ligne. Vous pouvez utiliser le cursor.pretty() pour configurer le curseur afin d'afficher les résultats dans un format plus lisible.
 

 Pour utiliser le pretty() méthode, ajoutez-la à la find() méthode.
 

 Exemple :
 
db.pets.find({ "_id": 6 }).pretty() 
 

 Résultat :
 
{ "_id" :6, "name" :"Fetch", "type" :"Chien", "specs" :{ "height" :400, "weight" :15, "color" :"brown" }}
 
Tableaux
 

 Vous pouvez référencer des données dans des tableaux en référençant l'élément du tableau par son index ou par sa valeur.
 

 Supposons que nous insérions le document suivant :
 
db.pets.insertOne({ "_id" :7, "name" :"Jake", "type" :"Chien", "awards" :[ "Top Dog", "Best Dog", "Biggest Dog " ]})
 

 Si nous voulions trouver tous les chiens avec le prix Top Dog, nous pourrions écrire la requête suivante (qui renverra le chien ci-dessus).
 
db.pets.find({ 
    "awards": "Top Dog"
}).pretty() 
 

 Résultat :
 
{ "_id" :7, "name" :"Jake", "type" :"Dog", "awards" :[ "Top Dog", "Best Dog", "Biggest Dog" ]}
 

 Vous pouvez également spécifier l'index de l'élément, comme ceci :
 
db.pets.find({ 
    "awards.0": "Top Dog"
}).pretty() 
 

 Cela nécessite que la valeur spécifiée soit à l'index spécifié. Par conséquent, la requête suivante ne renvoie pas le même chien.
 
db.pets.find({ 
    "awards.1": "Top Dog"
}).pretty() 
 

 Notez que les tableaux sont basés sur zéro, donc un index de 0 spécifie le premier élément, 1 spécifie le deuxième élément, et ainsi de suite. 
 
Projections
 

 Par défaut, tous les champs du document sont renvoyés lorsque vous utilisez find() . Mais vous pouvez utiliser des projections pour réduire le nombre de champs renvoyés si nécessaire.
 

 Vous vous souviendrez peut-être que la syntaxe de find() va comme ceci :
 
db.collection.find(query, projection) 
 

 Où query fournit les critères de filtrage (ce que nous avons fait dans les exemples ci-dessus) et la projection est une projection facultative qui spécifie les champs à renvoyer à partir des documents correspondants. Par conséquent, si nous voulons utiliser une projection, nous la mettons simplement après la requête.
 

 Lorsque vous utilisez une projection, vous pouvez spécifier les champs à inclure , les champs à exclure , ou les deux. Pour cela, listez le nom du champ et soit un 1 (pour l'inclure) ou 0 (pour l'exclure).
 

 A ce jour, notre collection contient les documents suivants :
 
{ "_id" :1, "name" :"Wag", "type" :"Chien", "weight" :20 }{ "_id" :2, "name" :"Bark", "type" :"Chien", "poids" :10 }{ "_id" :3, "nom" :"Miaou", "type" :"Chat", "poids" :7 }{ "_id" :4, "nom" :"Scratch", "type" :"Chat", "weight" :8 }{ "_id" :5, "name" :"Bruce", "type" :"Bat", "weight" :3 }{ " _id" :6, "name" :"Fetch", "type" :"Chien", "specs" :{ "height" :400, "weight" :15, "color" :"brown" } }{ "_id " :7, "name" :"Jake", "type" :"Dog", "awards" :[ "Top Dog", "Best Dog", "Biggest Dog" ] }
 

 Voici un exemple d'utilisation d'une projection pour spécifier les champs à inclure :
 
db.pets.find({}, { name: 1, type: 1 }) 
 

 Résultat :
 
{ "_id" :1, "name" :"Wag", "type" :"Chien" }{ "_id" :2, "name" :"Bark", "type" :"Chien" }{ "_id" :3, "name" :"Meow", "type" :"Chat" }{ "_id" :4, "name" :"Scratch", "type" :"Chat" }{ "_id" :5, "name" :"Bruce", "type" :"Bat" }{ "_id" :6, "name" :"Fetch", "type" :"Chien" }{ "_id" :7, "name " :"Jake", "type" :"Chien" }
 

 Notez que le _id champ est renvoyé même si nous ne l'avons pas inclus dans notre projection. Ce champ est une exception et est inclus par défaut. 
 

 Si vous ne voulez pas le _id champ à renvoyer, vous devez l'exclure explicitement.
 
db.pets.find({}, { _id: 0, name: 1, type: 1 }) 
 

 Résultat :
 
{ "name" :"Wag", "type" :"Chien" }{ "name" :"Bark", "type" :"Chien" }{ "name" :"Meow", "type" :"Chat" }{ "nom" :"Scratch", "type" :"Chat" }{ "nom" :"Bruce", "type" :"Chauve-souris" }{ "nom" :"Récupérer", "type" :"Chien" }{ "nom" :"Jake", "type" :"Chien" }
 

 Voici un autre exemple, cette fois nous ne spécifions que les champs à exclure.
 
db.pets.find({}, { _id: 0, weight: 0, specs: 0, awards: 0 }) 
 

 Résultat :
 
{ "name" :"Wag", "type" :"Chien" }{ "name" :"Bark", "type" :"Chien" }{ "name" :"Meow", "type" :"Chat" }{ "nom" :"Scratch", "type" :"Chat" }{ "nom" :"Bruce", "type" :"Chauve-souris" }{ "nom" :"Récupérer", "type" :"Chien" }{ "nom" :"Jake", "type" :"Chien" }
 
Plus de projections
 

 Il y a plusieurs autres choses que vous pouvez faire avec les projections. Par exemple, à partir de MongDB 4.4, vous pouvez utiliser des expressions agrégées pour spécifier la valeur d'un champ projeté.
 

 Exemple :
 
db.pets.find({}, { 
    "_id": 0,
    "n": "$name", 
    "t": "$type", 
    "w": "$weight" 
    }) 
 

 Résultat :
 
{ "n" :"Wag", "t" :"Chien", "w" :20 }{ "n" :"Aboiement", "t" :"Chien", "w" :10 }{ "n" :"Miaou", "t" :"Chat", "w" :7 }{ "n" :"Scratch", "t" :"Chat", "w" :8 }{ "n" :"Bruce", "t" :"Bat", "w" :3 }{ "n" :"Aller chercher", "t" :"Chien" }{ "n" :"Jake", "t" :"Chien " } 

 Ici, nous avons renommé les noms de champs. Nous avons fait cela en spécifiant un nouveau nom pour chaque champ en tant que littéral de chaîne, en utilisant le $fieldName syntaxe pour afficher cette valeur de champs. Le résultat est un peu comme utiliser des alias en SQL.
 
Plus d'informations
 

 Consultez la documentation MongoDB pour plus d'informations.