MongoDB findOne()

Dans MongoDB, le db.collection.findOne() renvoie un document qui satisfait les critères de requête spécifiés sur la collection ou la vue.

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

findOne() est similaire à find() , sauf que findOne() ne renvoie que le premier document correspondant aux critères du filtre, selon l'ordre naturel qui reflète l'ordre des documents sur le disque.

Le find() d'autre part, renvoie tous les documents correspondants.

Aussi, findOne() renvoie le document réel, alors que find() ne renvoie qu'un curseur à chaque document. Par conséquent, vous ne pouvez pas appliquer de méthodes de curseur à findOne() comme vous pouvez avec find() .

Exemple

Supposons que nous ayons une collection appelée pets avec 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" :"Cat", "weight" :8 }{ "_id" :5, "name" :"Bruce", "type" :"Bat", "weight" :3 } 

 Nous pouvons utiliser findOne() pour retourner un document.
 
db.pets.findOne() 
 

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

 Ici, nous avons cherché dans tous les documents de pets le recueil. Nous savons que cela a recherché tous les documents car nous n'avons fourni aucun critère de filtrage. Nous n'avons même pas fourni d'arguments.
 

 Lorsqu'il est appelé sans arguments, findOne() recherche tous les documents d'une collection et renvoie tous les champs du document correspondant.
 

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

 Dans ce cas, nous passons un document vide. 
 

 En ajoutant à ce document vide, nous pouvons commencer à filtrer les résultats.
 
Fournir une requête
 

 La syntaxe réelle de findOne() va comme ceci :
 
db.collection.findOne(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 la portée de la recherche uniquement sur les documents qui correspondent à la requête. 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.findOne({"type":"Cat"}) 
 

 Résultat :
 
{ "_id" :3, "name" :"Meow", "type" :"Chat", "weight" :7 }
 

 Cela a limité la recherche aux seuls documents qui ont un type champ avec une valeur de Cat , puis findOne() a renvoyé le premier document à partir de ce résultat. 
 

 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.findOne({"weight": { $lt: 10 }}) 
 

 Résultat :
 
{ "_id" :3, "name" :"Meow", "type" :"Chat", "weight" :7 }
 
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.findOne({ "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.findOne({ 
    "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.findOne({ 
    "specs" : {
		"height" : 400
	}
 }) 
 

 Résultat :
 
null
 
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.findOne({ 
    "awards": "Top Dog"
}) 
 

 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.findOne({ 
    "awards.0": "Top Dog"
}) 
 

 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.findOne({ 
    "awards.1": "Top Dog"
}) 
 

 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 findOne() . 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 findOne() va comme ceci :
 
db.collection.findOne(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).
 

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

 Résultat :
 
{ "_id" :1, "name" :"Wag", "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.findOne({}, { _id: 0, name: 1, type: 1 }) 
 

 Résultat :
 
{ "name" :"Wag", "type" :"Chien" }
 

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

 Résultat :
 
{ "name" :"Wag", "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.findOne({}, { 
    "_id": 0,
    "n": "$name", 
    "t": "$type", 
    "w": "$weight" 
    }) 
 

 Résultat :
 
{ "n" :"Wag", "t" :"Chien", "w" :20 }
 

 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.