Vad är MongoDB findOne och hur använder man det?

MongoDB:s findOne-metod är utmärkt för att söka i en samling. Den returnerar dock bara ett enda resultat, vilket gör den olämplig för många typer av sökningar.

Vad är MongoDB findOne?

MongoDB är ett databashanteringssystem som enkelt kan lagra och hantera stora mängder data tack vare sin NoSQL-strategi och enastående skalbarhet. Även om dessa aspekter erbjuder användarna betydande fördelar, innebär det också att systemet behöver kraftfulla metoder för att säkerställa att användarna effektivt kan navigera i databasen.

Systemet sparar alla typer av data i form av ett BSON-dokument (binär JSON) och samlar dessa dokument i samlingar. Om du vill söka efter och visa ett av dessa dokument finns det flera alternativ att välja mellan. Förutom den mer allmänna sökmetoden MongoDB find är MongoDB findOne en mycket effektiv metod för att filtrera stora databaser med precision.

MongoDB findOne söker igenom alla dokument och samlingar enligt vissa kriterier som anges av användaren. Det speciella med denna metod är att den alltid returnerar exakt ett dokument. Om det bara finns ett dokument i sökfrågan returneras detta dokument. Om flera dokument matchar de parametrar som definierats av användaren returnerar MongoDB findOne det dokument som visas först i databasens naturliga ordning. Om inga dokument kan hittas i sökningen är resultatet ”null”.

Vad är syntaxen för MongoDB findOne?

Den grundläggande syntaxen för MongoDB findOne är enkel. Metoden används på följande sätt:

db.collection.findOne ( <query>, <projection>, <options> )

Under <query> kan du ange hur metoden ska filtrera dokumenten.

Under <projection> kan du ange vilka fält som ska visas för det dokument som returneras. Använd de booleska värdena 1 (sant/inkludera) och 0 (falskt/exkludera) för att ange om ett fält ska inkluderas. Om denna parameter förblir tom visas alla fält.

Den tredje sökparametern <options> gör det möjligt att ytterligare modifiera sökningen och även ändra visningen. Alla tre sökparametrarna är valfria.

Hur man skapar en samling för teständamål

Om du har installerat MongoDB på Linux, Windows eller Mac och vill använda MongoDB findOne är det värt att skapa en testmiljö för att experimentera med metoden.

Om du ännu inte har skapat en databas kan du läsa vår omfattande MongoDB-handledning för att lära dig hur man gör det. I vårt exempel nedan kommer vi att använda en anställdsdatabas som innehåller fem poster. Varje post innehåller information om anställdas namn, kön och ålder samt hur länge personen har varit anställd på företaget. Samlingen ser ut så här:

# Create Collection
db.employee.insertMany ( [
    {
    name : "Smith",
    gender : "Female",
    age : 56,
    year : 2002
    },
    {
    name : "Jones",
    gender : "Female",
    age : 40,
    year : 2017,
    },
    {
    name : "Brown",
    gender : "Male",
    age : 40,
    year : 2019
    },
    {
    name : "Michaels",
    gender : "Female",
    age : 44,
    year : 2015
    },
    name : "Cartwright",
    gender : "Male",
    age : 22,
    year : 2022
    }
]
)

Vilka olika sätt finns det att söka med Mongo DB findOne?

Det finns flera sätt att söka efter information med MongoDB findOne. Du kan söka utan parametrar, med ett ID, med ett fält eller med flera fält.

Sökning utan parametrar

Om du använder MongoDB-metoden findOne utan några parametrar kommer systemet att söka igenom din databas och ta hänsyn till alla poster. I vårt exempel innebär detta att metoden kommer att identifiera fem poster. Eftersom inga dokument utesluts och metoden endast returnerar ett resultat kommer MongoDB findOne att välja den första personen som matades in i databasen.

db.employee.findOne ( )

Resultatet är:

db.employee.findOne ( )
{
    _id : ObjectID ( "529ete7300of4002bme148om" ),
    name : "Smith",
    gender : "Female",
    age : 56,
    year : 2002
}

Sökning efter ID

Normalt vill du ange någon form av kriterier för din sökning så att du hittar det dokument du faktiskt behöver. Ett sätt att söka efter dokument med MongoDB findOne är att söka efter ett ID.

Fältet _id är unikt i varje dokument. I vårt exempel representerar varje ID exakt en anställd. Om du kör MongoDB findOne med objekt-ID:t får du exakt det resultat du söker.

db.employee.findOne ( { _id : ObjectID ( "582pfh773813tw982qj411l0" ) } )

Resultatet ser ut så här:

db.employee.findOne ( { _id : ObjectID ( "582pfh773813tw982qj411l0" ) } )
{
    _id : ObjectID ( "582pfh773813tw982qj411l0"
    name : "Cartwright",
    gender : "Male",
    age : 22,
    year : 2022
}

Söka med hjälp av specifika fält

Om du inte känner till ID:t eller vill söka i din samling efter andra parametrar kan du också använda MongoDB findOne för att söka efter specifika fält. Om det bara finns ett dokument som matchar parametern är det det dokumentet som visas. Om flera dokument matchar dina sökkriterier visar systemet dock bara den första posten.

I exemplet nedan ska vi söka efter alla poster där könet är angivet som ”Man”. Här är kommandot:

db.employee.findOne ( { gender : "Male" } )

Det finns två poster som matchar dessa kriterier, men endast en visas. Resultatet visar den anställde Mr Brown:

db.employee.findOne ( { gender : "Male" } )
{
    _id : ObjectID ( "498p0t173mv489fh63th00kh"
    name : "Brown",
    gender : "Male",
    age : 40,
    year : 2019
}

Söka med hjälp av flera fält

Du har också möjlighet att begränsa sökningen ytterligare för att undvika överlappningar. Detta är kanske inte nödvändigt för vår lilla samling av exempel, men om du arbetar med flera hundra eller till och med tusentals poster kan denna funktion vara användbar. MongoDB findOne låter dig använda flera fält för sökningen. Om du vill identifiera en anställd efter kön (man) och ålder kan du skriva följande:

db.employee.findOne ( { gender : "Male", age: 40 } )

Resultatet visar återigen Mr Brown, som är den enda personen i samlingen som är man och 40 år gammal. Ms Jones är i samma ålder, men hennes kön stämmer inte överens med kriterierna, så resultatet ser ut så här:

db.employee.findOne ( { gender : "Male", age: 40 } )
{
    _id : ObjectID ( "498p0t173mv489fh63th00kh"
    name : "Brown",
    gender : "Male",
    age : 40,
    year : 2019
}

Hur man ställer in villkor för ett fält med MongoDB findOne

Det är också möjligt att definiera villkor för ett specifikt fält och använda dessa som sökkriterier. I följande exempel söker vi endast efter anställda som är över 30 år.

Denna post ser ut så här:

db.employee.findOne ( { age : { $gt : 30 } } )

Detta utesluter Mr Cartwright. Eftersom Ms Smith är över 30 år och är den första personen i listan visas hon som resultat:

db.employee.findOne ( { age : { $gt : 30 } } )
{
    _id : ObjectID ( "529ete7300of4002bme148om" ),
    name : "Smith",
    gender : "Female",
    age : 56,
    year : 2002
}

Hur man utesluter fält med MongoDB findOne

Om du har omfattande samlingar som innehåller mycket information kan utdata innehålla för mycket information. Lyckligtvis erbjuder MongoDB findOne också möjligheten att utesluta fält från utdata. I följande exempel vill vi inte visa ID, kön och ålder i utdata.

db.employee.findOne ( { name : "Smith" }, { _id : 0, gender : 0, age : 0 } )

Du får följande resultat:

db.employee.findOne ( { name : "Smith" }, { _id : 0, gender : 0, age : 0 } )
{
    name : "Smith",
    year : 2002
}

Vad händer om MongoDB findOne inte hittar några resultat för min sökning?

Om det inte finns några resultat för din sökning med MongoDB findOne visas ändå ett resultat. För att illustrera vad som händer söker vi efter Ms. Larkham, som inte finns i samlingen.

db.employee.findOne ( { name : "Larkham" }  )

Resultatet för detta är:

db.employee.findOne ( { name : "Larkham" }  )
null