{"id":45789,"date":"2022-09-19T10:37:22","date_gmt":"2022-09-19T08:37:22","guid":{"rendered":"https:\/\/kinqsta.com\/nl\/?p=45789&#038;preview=true&#038;preview_id=45789"},"modified":"2023-06-15T11:36:43","modified_gmt":"2023-06-15T09:36:43","slug":"mongodb-operators","status":"publish","type":"post","link":"https:\/\/kinqsta.com\/nl\/blog\/mongodb-operators\/","title":{"rendered":"9 soorten Mongodb operators die je moet kennen"},"content":{"rendered":"<p>In elk bedrijf zijn gegevens je grootste troef. Door gegevens te analyseren kun je beslissingen nemen over klantentrends en kan je gedrag voorspellen. Dit verhoogt de winstgevendheid van het bedrijf en de effectieve besluitvorming.<\/p>\n<p>Zonder <a href=\"https:\/\/kinqsta.com\/nl\/blog\/open-source-database\/\">databasesoftware<\/a> zou een eenvoudige taak als het vinden van het gemiddelde van alle waarden in een systeem vol records al snel vervelend worden. Gelukkig hebben databases het analyseren van gegevens gemakkelijker en sneller gemaakt met functies en operators.<\/p>\n\n<p>Dit artikel zal een en ander uitleggen over de operators die in de MongoDB databasesoftware worden gebruikt.<\/p>\n<div><\/div><kinsta-auto-toc heading=\"Table of Contents\" exclude=\"last\" list-style=\"arrow\" selector=\"h2\" count-number=\"-1\"><\/kinsta-auto-toc>\n<h2>Wat zijn MongoDB operators?<\/h2>\n<p><a href=\"https:\/\/kinqsta.com\/blog\/what-is-mongodb\/\">MongoDB<\/a> is een NoSQL databasesoftware die documentgeori\u00ebnteerde informatie beheert.<\/p>\n<p>Een van de belangrijkste kenmerken van MongoDB is zijn snelheid. Om queries sneller terug te geven kan MongoDB operators gebruiken om specifieke functies uit te voeren.<\/p>\n<p>Operators zijn speciale symbolen die compilers helpen bij het uitvoeren van wiskundige of logische taken. MongoDB biedt verschillende soorten operators voor interactie met de database.<\/p>\n<h2>MongoDB operatortypes<\/h2>\n<p>Er zijn negen soorten operators, elk genoemd naar zijn functie. Zo gebruiken logische operators logische bewerkingen. Om ze uit te voeren moet je een specifiek sleutelwoord gebruiken en de syntaxis volgen. Ze zijn echter vrij gemakkelijk te volgen!<\/p>\n<p>Aan het eind van dit artikel zul je de basis van elke operator en zijn functies kennen.<\/p>\n<h3>Logische operators<\/h3>\n<p>Logische operators worden vaak gebruikt om gegevens te filteren op basis van de gegeven voorwaarden. Ze maken ook de evaluatie van vele voorwaarden mogelijk, die we nader zullen bespreken.<\/p>\n<p>Hieronder staan enkele logische operators die je kunt gebruiken:<\/p>\n<h4>$and<\/h4>\n<p>Een &#8220;and&#8221; condition voert een logische &#8220;en&#8221; bewerking uit op een matrix van twee of meer expressions. Het selecteert de documenten waar aan <em>alle<\/em> voorwaarden van de expressions is voldaan.<\/p>\n<p>Dit is de standaard syntaxis voor de expression <code>$and<\/code>:<\/p>\n<pre><code class=\"language-php\">{ $and: [ { &lt;expression1&gt; }, { &lt;expression2&gt; }, ... , { &lt;expressionN&gt; } ] }<\/code><\/pre>\n<p>Als we bijvoorbeeld documenten willen selecteren waarvan de prijs $10 is en de hoeveelheid minder dan 15, kunnen we de volgende query invoeren:<\/p>\n<pre><code class=\"language-php\">db.inventory.find( { $and: [ { quantity: { $lt: 15 } }, { price: 10 } ] } )<\/code><\/pre>\n<h4>$or<\/h4>\n<p>Een &#8220;or&#8221; condition voert een logische &#8220;of&#8221; bewerking uit op een matrix van twee of meer expressions. Het selecteert de documenten waar minstens \u00e9\u00e9n van de expressions waar is.<\/p>\n<p>Dit is de standaard syntaxis voor de expression <code>$or<\/code>:<\/p>\n<pre><code class=\"language-php\">{ $or: [ { &lt;expression1&gt; }, { &lt;expression2&gt; }, ... , { &lt;expressionN&gt; } ] }.<\/code><\/pre>\n<p>Als we bijvoorbeeld documenten willen selecteren waar de prijs $10 of de hoeveelheid minder dan 15 is, kunnen we de volgende query invoeren:<\/p>\n<pre><code class=\"language-php\">db.inventory.find( { $or: [ { quantity: { $lt: 15 } }, { price: 10 } ] } )<\/code><\/pre>\n<p>We hoeven de expression niet te beperken tot twee criteria &#8211; we kunnen er meer toevoegen. De onderstaande query selecteert bijvoorbeeld die documenten waarvan de prijs gelijk is aan $10, de hoeveelheid kleiner is dan 15, of de tag stationair is:<\/p>\n<pre><code class=\"language-php\">db.inventory.find( { $or: [ { quantity: { $lt: 15 } }, { price: 10 }, { tag: \"stationary\" }] } )<\/code><\/pre>\n<p>Bij het uitvoeren van deze clausules voert MongoDB ofwel een verzamelscan of een indexscan uit. Als alle indexen de clausules ondersteunen, dan gebruikt MongoDB indexen om een <code>$or<\/code> expression te controleren. Anders gebruikt het in plaats daarvan een verzamelscan.<\/p>\n<p>Maar als je de criteria in hetzelfde veld wilt testen, kun je beter de <code>$in<\/code> operator gebruiken dan de <code>$or<\/code> operator. Als je bijvoorbeeld een verzameling documenten wilt waar de hoeveelheid ofwel 10 ofwel 20 is, moet je misschien in plaats daarvan de onderstaande <code>$in<\/code> query uitvoeren:<\/p>\n<pre><code class=\"language-php\">db.inventory.find ( { quantity: { $in: [20, 50] } } )<\/code><\/pre>\n<p>We behandelen later meer over de <code>$in<\/code> operator.<\/p>\n<h4>$nor<\/h4>\n<p>Deze operator voert een logische &#8220;nor&#8221; bewerking uit op een array met behulp van een of meer expressions. Vervolgens selecteert hij de documenten die niet voldoen aan de query-expressions. Eenvoudiger gezegd: hij doet het tegenovergestelde van de voorwaarde <code>$or<\/code>.<\/p>\n<p>Dit is de algemene syntaxis:<\/p>\n<pre><code class=\"language-php\">{ $nor: [ { &lt;expression1&gt; }, { &lt;expression2&gt; }, ...  { &lt;expressionN&gt; } ] }<\/code><\/pre>\n<p>Laten we de volgende query als voorbeeld nemen:<\/p>\n<pre><code class=\"language-php\">db.inventory.find( { $nor: [ { price: 3.99 }, { sale: true } ]  } )<\/code><\/pre>\n<p>Deze query selecteert de documenten die bevatten:<\/p>\n<ul>\n<li>een price veldwaarde die niet gelijk is aan $3,99, en een sale waarde die niet gelijk is aan true; of<\/li>\n<li>een price veldwaarde niet gelijk aan $3,99, en een leeg of afwezig sale veld; of<\/li>\n<li>geen price veld, en een sale veld niet gelijk aan waar; of<\/li>\n<li>noch price veld, noch sale veld ingevuld of aanwezig.<\/li>\n<\/ul>\n<h4>$not<\/h4>\n<p>Deze operator voert een logische &#8220;niet&#8221; operatie uit op een array voor de gespecificeerde expression. Het selecteert vervolgens de documenten die niet overeenkomen met de query expressions. Hieronder vallen documenten die het veld niet bevatten.<\/p>\n<p>Dit is de algemene syntaxis:<\/p>\n<pre><code class=\"language-php\">{ field: { $not: { &lt;operator-expression&gt; } } }<\/code><\/pre>\n<p>Neem bijvoorbeeld de volgende query:<\/p>\n<pre><code class=\"language-php\">db.inventory.find( { price: { $not: { $lt: 3.99 } } } )<\/code><\/pre>\n<p>Deze query zou die documenten selecteren die bevatten:<\/p>\n<ul>\n<li>een price veld waarvan de waarde groter is dan of gelijk aan $3,99; en<\/li>\n<li>een prijsveld niet ingevuld of niet bestaand.<\/li>\n<\/ul>\n<aside role=\"note\" class=\"wp-block-kinsta-notice is-style-info\">\n            <h3>Info<\/h3>\n        <p><code>{ $not: { $lt: 3.99 } }<\/code> is anders dan de <code>$gte<\/code> operator. <code>{ $gte: 3.99 }<\/code> retourneert alleen de documenten waarin het prijsveld bestaat en de waarde ervan groter of gelijk is aan $3,99 (de<code> $not<\/code> operator retourneert zelfs de documenten waarin het prijsveld niet bestaat).<\/p>\n<\/aside>\n\n<h3>Vergelijkingsoperators<\/h3>\n<p>Vergelijkingsoperators kunnen worden gebruikt om waarden in \u00e9\u00e9n of meer documenten te vergelijken.<\/p>\n<p>Hieronder staat een voorbeeldcode van een eenvoudige inventarisverzameling voor een supermarktwinkel:<\/p>\n<pre><code class=\"language-php\">{ _id: 1, item: { name: \"apple\", code: \"123\" }, qty: 15, tags: [ \"A\", \"B\", \"C\" ] },\n{ _id: 2, item: { name: \"banana\", code: \"123\" }, qty: 20, tags: [ \"B\" ] },\n{ _id: 3, item: { name: \"spinach\", code: \"456\" }, qty: 25, tags: [ \"A\", \"B\" ] },\n{ _id: 4, item: { name: \"lentils\", code: \"456\" }, qty: 30, tags: [ \"B\", \"A\" ] },\n{ _id: 5, item: { name: \"pears\", code: \"000\" }, qty: 20, tags: [ [ \"A\", \"B\" ], \"C\" ] },\n{ _id: 6, item: { name: \"strawberry\", code: \"123\" }, tags: [ \"B\" ] }<\/code><\/pre>\n<p>We zullen dit voorbeeld gebruiken terwijl we elke vergelijkingsoperator in detail bespreken.<\/p>\n<h4>Gelijk aan ($eq)<\/h4>\n<p>Deze operator komt overeen met waarden die gelijk zijn aan de gegeven waarde:<\/p>\n<pre><code class=\"language-php\">{ &lt;field&gt;: { $eq: &lt;value&gt; } }<\/code><\/pre>\n<p>Als we bijvoorbeeld een specifiek document uit de inventarisverzameling willen ophalen met de exacte hoeveelheidswaarde &#8220;20&#8221;, zouden we het volgende commando invoeren:<\/p>\n<pre><code class=\"language-php\">db.inventory.find( { qty: { $eq: 20 } } )<\/code><\/pre>\n<p>De query zou het volgende opleveren:<\/p>\n<pre><code class=\"language-php\">{ _id: 2, item: { name: \"banana\", code: \"123\" }, qty: 20, tags: [ \"B\" ] }, \n{ _id: 5, item: { name: \"pears\", code: \"000\" }, qty: 20, tags: [ [ \"A\", \"B\" ], \"C\" ] }<\/code><\/pre>\n<h4>Groter dan ($gt)<\/h4>\n<p>Deze operator komt overeen als de waarden groter zijn dan de gegeven waarde:<\/p>\n<pre><code class=\"language-php\">{ field: { $gt: value } }<\/code><\/pre>\n<p>In dit voorbeeld halen we de documenten op waarbij de hoeveelheid groter is dan 15:<\/p>\n<pre><code class=\"language-php\">db.inventory.find({\"qty\": { $gt: 15}})<\/code><\/pre>\n<p>De query zou het volgende opleveren:<\/p>\n<pre><code class=\"language-php\">{ _id: 2, item: { name: \"banana\", code: \"123\" }, qty: 20, tags: [ \"B\" ] }\n{ _id: 3, item: { name: \"spinach\", code: \"456\" }, qty: 25, tags: [ \"A\", \"B\" ] }\n{ _id: 4, item: { name: \"lentils\", code: \"456\" }, qty: 30, tags: [ \"B\", \"A\" ] }\n{ _id: 5, item: { name: \"pears\", code: \"000\" }, qty: 20, tags: [ [ \"A\", \"B\" ], \"C\" ] }<\/code><\/pre>\n<h4>Minder dan ($lt)<\/h4>\n<p>Deze operator komt overeen als waarden kleiner zijn dan de opgegeven waarde:<\/p>\n<pre><code class=\"language-php\">{ field: { $lt: value } }<\/code><\/pre>\n<p>Laten we de documenten vinden met een hoeveelheid van minder dan 25:<\/p>\n<pre><code class=\"language-php\">db.inventory.find({\"qty\": { $lt: 25}})<\/code><\/pre>\n<p>De query zou het volgende opleveren:<\/p>\n<pre><code class=\"language-php\">{ _id: 1, item: { name: \"apple\", code: \"123\" }, qty: 15, tags: [ \"A\", \"B\", \"C\" ] }\n{ _id: 2, item: { name: \"banana\", code: \"123\" }, qty: 20, tags: [ \"B\" ] }\n{ _id: 5, item: { name: \"pears\", code: \"000\" }, qty: 20, tags: [ [ \"A\", \"B\" ], \"C\" ] }<\/code><\/pre>\n<h4>Groter of gelijk aan ($gte)<\/h4>\n<p>Deze operator komt overeen als de waarden groter of gelijk zijn aan de gegeven waarde:<\/p>\n<pre><code class=\"language-php\">{ field: { $gte: value } }<\/code><\/pre>\n<p>In dit voorbeeld halen we de documenten op waarbij de hoeveelheid groter of gelijk is aan 25:<\/p>\n<pre><code class=\"language-php\">db.inventory.find({\"qty\": { $gte: 25}})<\/code><\/pre>\n<p>Deze query zou het volgende opleveren:<\/p>\n<pre><code class=\"language-php\">{ _id: 3, item: { name: \"spinach\", code: \"456\" }, qty: 25, tags: [ \"A\", \"B\" ] }\n{ _id: 4, item: { name: \"lentils\", code: \"456\" }, qty: 30, tags: [ \"B\", \"A\" ] }<\/code><\/pre>\n<h4>Minder of gelijk aan ($lte)<\/h4>\n<p>Deze operator komt alleen overeen als de waarden minder of gelijk zijn aan de gegeven waarde:<\/p>\n<pre><code class=\"language-php\">{ field: { $lte: value } }<\/code><\/pre>\n<p>Laten we de documenten vinden met een hoeveelheid kleiner dan of gelijk aan 25.<\/p>\n<pre><code class=\"language-php\">db.inventory.find({\"qty\": { $lte: 25}})<\/code><\/pre>\n<p>We kunnen verwachten dat deze query het volgende oplevert:<\/p>\n<pre><code class=\"language-php\">{ _id: 1, item: { name: \"apple\", code: \"123\" }, qty: 15, tags: [ \"A\", \"B\", \"C\" ] }\n{ _id: 2, item: { name: \"banana\", code: \"123\" }, qty: 20, tags: [ \"B\" ] }\n{ _id: 3, item: { name: \"spinach\", code: \"456\" }, qty: 25, tags: [ \"A\", \"B\" ] }\n{ _id: 5, item: { name: \"pears\", code: \"000\" }, qty: 20, tags: [ [ \"A\", \"B\" ], \"C\" ] }<\/code><\/pre>\n<h4>In ($in)<\/h4>\n<p>Deze operator geeft de documenten terug die overeenkomen met de opgegeven waarden:<\/p>\n<pre><code class=\"language-php\">{ field: { $in: [&lt;value1&gt;, &lt;value2&gt;, ... &lt;valueN&gt; ] } }<\/code><\/pre>\n<p>De waarde van een veld is gelijk aan een willekeurige waarde in de opgegeven matrix. Om bijvoorbeeld de documenten met de waarden &#8220;30&#8221; en &#8220;15&#8221; in de inventarisverzameling op te halen, zou je dit doen:<\/p>\n<pre><code class=\"language-php\">db.inventory.find({ \"qty\": { $in: [30, 15]}})<\/code><\/pre>\n<p>De uitvoer zou zijn:<\/p>\n<pre><code class=\"language-php\">{ _id: 1, item: { name: \"apple\", code: \"123\" }, qty: 15, tags: [ \"A\", \"B\", \"C\" ] }\n{ _id: 4, item: { name: \"lentils\", code: \"456\" }, qty: 30, tags: [ \"B\", \"A\" ] }<\/code><\/pre>\n<h4>Niet in ($nin)<\/h4>\n<p>Deze operator retourneert de documenten die niet overeenkomen met de gegeven waarden. Hier is de basissyntaxis van de operator <code>$nin<\/code>:<\/p>\n<pre><code class=\"language-php\">{ field: { $nin: [ &lt;value1&gt;, &lt;value2&gt; ... &lt;valueN&gt; ]<\/code><\/pre>\n<p><code>$nin<\/code> selecteert de documenten waar:<\/p>\n<ul>\n<li>de veldwaarde niet in de opgegeven matrix staat; of<\/li>\n<li>het veld niet bestaat.<\/li>\n<\/ul>\n<p>Als het veld arrays bevat, selecteert het arrays waar geen element gespecificeerd in de waarde-sectie aanwezig is. We willen bijvoorbeeld die documenten selecteren waarvan de hoeveelheid niet gelijk is aan 20 of 15.<\/p>\n<p>Bovendien komt het ook overeen met documenten die geen hoeveelheidsveld hebben:<\/p>\n<pre><code>db.inventory.find({ \"qty\": { $nin: [ 20, 15 ]}})<\/code><\/pre>\n<p>De uitvoer zou zijn:<\/p>\n<pre><code class=\"language-php\">{ _id: 3, item: { name: \"spinach\", code: \"456\" }, qty: 25, tags: [ \"A\", \"B\" ] }\n{ _id: 4, item: { name: \"lentils\", code: \"456\" }, qty: 30, tags: [ \"B\", \"A\" ] }\n{ _id: 6, item: { name: \"strawberry\", code: \"123\" }, tags: [ \"B\" ] }<\/code><\/pre>\n<h4>Niet gelijk ($ne)<\/h4>\n<p>De operator <code>$ne<\/code> geeft de documenten terug waarin de opgegeven waarde niet gelijk is:<\/p>\n<pre><code class=\"language-php\">{ $ne: value } }<\/code><\/pre>\n<p>Stel bijvoorbeeld dat we alle documenten willen selecteren waarbij de hoeveelheid niet gelijk is aan 20:<\/p>\n<pre><code class=\"language-php\">db.inventory.find( { qty: { $ne: 20 } } )<\/code><\/pre>\n<p>De uitvoer zou zijn:<\/p>\n<pre><code class=\"language-php\">{ _id: 1, item: { name: \"apple\", code: \"123\" }, qty: 15, tags: [ \"A\", \"B\", \"C\" ] }\n{ _id: 3, item: { name: \"spinach\", code: \"456\" }, qty: 25, tags: [ \"A\", \"B\" ] }\n{ _id: 4, item: { name: \"lentils\", code: \"456\" }, qty: 30, tags: [ \"B\", \"A\" ] }\n{ _id: 6, item: { name: \"strawberry\", code: \"123\" }, tags: [ \"B\" ] }<\/code><\/pre>\n<p>Uit bovenstaande uitvoer kunnen we zien dat de query documenten zal selecteren die geen hoeveelheidsveld hebben.<\/p>\n<h3>Element operators<\/h3>\n<p>De element query operators kunnen documenten identificeren aan de hand van de velden van het document. Element operators bestaan uit <code>$exist<\/code> en <code>$type<\/code>.<\/p>\n<h4>$exists<\/h4>\n<p>Deze operator komt overeen met documenten die een gespecificeerd veld hebben. Deze operator kent een booleaanse waarde die <code>true<\/code> of <code>false<\/code> kan zijn.<\/p>\n<p>Als het is opgegeven als <code>true<\/code>, komt het overeen met de documenten die dat veld bevatten, inclusief documenten waarin de veldwaarde nul is. Als &lt;boolean&gt; <code>false<\/code> is, dan geeft de query alleen de documenten die het veld niet bevatten.<\/p>\n<p>Hier is de standaard syntaxis:<\/p>\n<pre><code class=\"language-php\">{ field: { $exists: &lt;boolean&gt; } })<\/code><\/pre>\n<p>Laten we een voorbeeld nemen waarbij we een verzameling gegevens hebben voor een array met de naam &#8220;bagofmarbles&#8221;, waarbij elke zak knikkers van verschillende kleuren bevat:<\/p>\n<pre><code class=\"language-php\">{ red: 5, green: 5, blue: null }\n{ red: 3, green: null, blue: 8 }\n{ red: null, green: 3, blue: 9 }\n{ red: 1, green: 2, blue: 3 }\n{ red: 2, blue: 5 }\n{ red: 3, green: 2 }\n{ red: 4 }\n{ green: 2, blue: 4 }\n{ green: 2 }\n{ blue: 6 }<\/code><\/pre>\n<p>Laten we zeggen dat we een query willen die alleen die zakken oplevert waarin de rode knikkers voorkomen. Dit betekent dat we de booleaanse waarde moeten invoeren als <code>true<\/code>. Laten we eens kijken:<\/p>\n<pre><code class=\"language-php\">db.bagofmarbles.find( { red: { $exists: true } } )<\/code><\/pre>\n<p>Het resultaat zou bestaan uit de documenten die het veld &#8220;red&#8221; bevatten, zelfs als de waarde <code>null<\/code> was. Het zou echter niet bestaan uit de documenten waarin het veld &#8220;red&#8221; niet eens bestaat:<\/p>\n<pre><code class=\"language-php\">{ red: 5, green: 5, blue: null }\n{ red: 3, green: null, blue: 8 }\n{ red: null, green: 3, blue: 9 }\n{ red: 1, green: 2, blue: 3 }\n{ red: 2, blue: 5 }\n{ red: 3, green: 2 }\n{ red: 4 }<\/code><\/pre>\n<p>Als we alleen die zakken wilden hebben waar rode knikkers niet eens als veld bestaan, kunnen we de onderstaande query invoeren:<\/p>\n<pre><code class=\"language-php\">db.bagofmarbles.find( { red: { $exists: false} )<\/code><\/pre>\n<p>De resultaten zouden bestaan uit die documenten die het veld &#8220;red&#8221; niet bevatten:<\/p>\n<pre><code class=\"language-php\">{ green: 2, blue: 4 }\n{ green: 2 }\n{ blue: 6 }<\/code><\/pre>\n<h4>$type<\/h4>\n<p>Deze operator matcht documenten volgens het opgegeven veldtype. Dit is handig als je zeer ongestructureerde gegevens hebt, of als de datatypes niet voorspelbaar zijn. Deze veldtypen zijn gespecificeerde BSON-typen en kunnen worden gedefinieerd met een typenummer of een alias.<\/p>\n<p>Dit is de algemene syntaxis voor <code>$type<\/code>:<\/p>\n<pre><code class=\"language-php\">{ field: { $type: &lt;BSON type&gt; } }<\/code><\/pre>\n<p>Laten we zeggen dat we een adresboek hebben dat de onderstaande documenten bevat:<\/p>\n<pre><code class=\"language-php\">db={\n  addressBook: [\n    {\n      \"_id\": 1,\n      address: \"2100 Jupiter Spot\",\n      zipCode: \"9036325\"\n    },\n    {\n      \"_id\": 2,\n      address: \"25 Moon Place\",\n      zipCode: 26237\n    },\n    {\n      \"_id\": 3,\n      address: \"2324 Neptune Ring\",\n      zipCode: NumberLong(77622222)\n    },\n    {\n      \"_id\": 4,\n      address: \"33 Saturns Moon\",\n      zipCode: NumberInt(117)\n    },\n    {\n      \"_id\": 5,\n      address: \"1044 Venus Lane\",\n      zipCode: [\n        \"99883637232\",\n        \"73488976234\"\n      ]\n    }\n  ]\n}<\/code><\/pre>\n<p>Bij het kijken naar bovenstaande documenten zie je dat de postcodes verschillende gegevenstypen hebben. Ze zijn lange, dubbele, gehele en string waarden.<\/p>\n<p>Als we alleen die documenten willen die een bepaald datatype als postcode hebben &#8211; laten we in dit geval een string nemen &#8211; dan moeten we de volgende query invoeren in de compiler:<\/p>\n<pre><code class=\"language-php\">db.addressBook.find({\n  \"zipCode\": {\n    $type: \"string\"\n  }\n})<\/code><\/pre>\n<p>Dit zou de volgende documenten opleveren:<\/p>\n<pre><code class=\"language-php\">[\n  {\n    \"_id\": 1,\n    \"address\": \"2100 Jupiter Spot\",\n    \"zipCode\": \"9036325\"\n  },\n  {\n    \"_id\": 5,\n    \"address\": \"1044 Venus Lane\",\n    \"zipCode\": [\n      \"99883637232\",\n      \"73488976234\"\n    ]\n  }\n]<\/code><\/pre>\n<p>Daarnaast is er een type &#8220;number&#8221;, dat alle lange, gehele of dubbele waarden omvat als een array met een element van de gespecificeerde types:<\/p>\n<pre><code class=\"language-php\">db.addressBook.find( { \"zipCode\" : { $type : \"number\" } } )<\/code><\/pre>\n<p>Uitvoer:<\/p>\n<pre><code class=\"language-php\">[\n{\n      \"_id\": 2,\n      address: \"25 Moon Place\",\n      zipCode: 26237\n    },\n    {\n      \"_id\": 3,\n      address: \"2324 Neptune Ring\",\n      zipCode: NumberLong(77622222)\n    },\n    {\n      \"_id\": 4,\n      address: \"33 Saturns Moon\",\n      zipCode: NumberInt(117)\n    }\n]<\/code><\/pre>\n<p>Als de documenten een array-veldtype hebben, geeft de operator <code>$type<\/code> de documenten terug waarin ten minste \u00e9\u00e9n array-element overeenkomt met het aan de operator doorgegeven type.<\/p>\n<aside role=\"note\" class=\"wp-block-kinsta-notice is-style-info\">\n            <h3>Info<\/h3>\n        <p>Vanaf MongoDB 3.6 en later geeft een query op <code>$type: \"array\"<\/code> documenten terug waarvan het veld zelf een array is. Bij gebruik van dezelfde query retourneerden de vorige versies echter documenten waarbij het veld een array is, en ten minste \u00e9\u00e9n element van het gegevenstype array was.<\/p>\n<\/aside>\n\n<h3>Array operators<\/h3>\n<p>MongoDB bestaat ook uit array operators, om documenten met arrays te query&#8217;en.<\/p>\n<p>Er zijn drie primaire operators: <code>$all<\/code>, <code>$elemMatch<\/code> en <code>$size<\/code>. Hieronder bespreken we ze elk in detail.<\/p>\n<h4>$all<\/h4>\n<p>De operator <code>$all<\/code> kiest de documenten waarin de waarde van een veld een array is met de opgegeven elementen:<\/p>\n<pre><code class=\"language-php\">{ : { $all: [ &lt;value1&gt; , &lt;value2&gt; ... ] } }<\/code><\/pre>\n<p>Stel bijvoorbeeld dat we een verzameling documenten hebben voor een kledingwinkel, met wat je hieronder ziet als inventaris.<\/p>\n<pre><code class=\"language-php\">{\n   _id: ObjectId(\"5234cc89687ea597eabee675\"),\n   code: \"shirt\",\n   tags: [ \"sale\", \"shirt\", \"button\", \"y2k\", \"casual\" ],\n   qty: [\n          { size: \"S\", num: 10, color: \"blue\" },\n          { size: \"M\", num: 45, color: \"blue\" },\n          { size: \"L\", num: 100, color: \"green\" }\n        ]\n},\n\n{\n   _id: ObjectId(\"5234cc8a687ea597eabee676\"),\n   code: \"pant\",\n   tags: [ \"y2k\", \"trendy\", \"shine\" ],\n   qty: [\n          { size: \"6\", num: 100, color: \"green\" },\n          { size: \"6\", num: 50, color: \"blue\" },\n          { size: \"8\", num: 100, color: \"brown\" }\n        ]\n},\n\n{\n   _id: ObjectId(\"5234ccb7687ea597eabee677\"),\n   code: \"pant2\",\n   tags: [ \"trendy\", \"shine\" ],\n   qty: [\n          { size: \"S\", num: 10, color: \"blue\" },\n          { size: \"M\", num: 100, color: \"blue\" },\n          { size: \"L\", num: 100, color: \"green\" }\n        ]\n},\n\n{\n   _id: ObjectId(\"52350353b2eff1353b349de9\"),\n   code: \"shirt2\",\n   tags: [ \"y2k\", \"trendy\" ],\n   qty: [\n          { size: \"M\", num: 100, color: \"green\" }\n        ]\n}<\/code><\/pre>\n<p>We willen alle documenten (in dit geval de kleding) uit de inventaris halen die gekoppeld zijn aan de tags &#8220;trendy&#8221; en &#8220;y2k&#8221;. De onderstaande query gebruikt de operator <code>$all<\/code> waarbij de waarde van het veld tags een array is waarvan de elementen &#8220;y2k&#8221; en &#8220;trendy&#8221; zijn:<\/p>\n<pre><code class=\"language-php\">db.inventory.find( { tags: { $all: [ \"y2k\", \"trendy\" ] } } )<\/code><\/pre>\n<p>Bovenstaande query levert het volgende op:<\/p>\n<pre><code class=\"language-php\">{\n   _id: ObjectId(\"5234cc8a687ea597eabee676\"),\n   code: \"pant\",\n   tags: [ \"y2k\", \"trendy\", \"shine\" ],\n   qty: [\n          { size: \"6\", num: 100, color: \"green\" },\n          { size: \"6\", num: 50, color: \"blue\" },\n          { size: \"8\", num: 100, color: \"brown\" }\n        ]\n}\n\n{\n   _id: ObjectId(\"52350353b2eff1353b349de9\"),\n   code: \"shirt2\",\n   tags: [ \"y2k\", \"trendy\" ],\n   qty: [\n          { size: \"M\", num: 100, color: \"green\" }\n        ]\n}<\/code><\/pre>\n<p>Uit het bovenstaande voorbeeld blijkt ook dat de operator <code>$all<\/code> gewoon dezelfde functie uitvoert als de operatie <code>$and<\/code>.<\/p>\n<p>Als alternatief zouden we de onderstaande query kunnen gebruiken, die een soortgelijke uitvoer zou geven als de bovenstaande:<\/p>\n<pre><code class=\"language-php\">db.inventory.find({\n  $and: [\n    {\n      tags: \"y2k\"\n    },\n    {\n      tags: \"trendy\"\n    }\n  ]\n})<\/code><\/pre>\n<h4>$elemMatch<\/h4>\n<p>De operator <code>$elemMatch<\/code> komt overeen met documenten die een matrixveld bevatten met ten minste \u00e9\u00e9n element dat overeenkomt met alle opgegeven querycriteria:<\/p>\n<pre><code class=\"language-php\">{ : { $elemMatch: { &lt;query1&gt;, &lt;query2&gt;, ... } } }<\/code><\/pre>\n<p>Hoewel we vergelijkingsoperators kunnen gebruiken zoals <code>$lte<\/code> en <code>$gte<\/code>, als we slechts een enkele queryvoorwaarde specificeren binnen <code>$elemMatch<\/code>, en de <code>$not<\/code> of de <code>$ne<\/code> operators niet gebruiken, kan het gebruik van <code>$elemMatch<\/code> worden weggelaten, omdat het in wezen dezelfde functie zou uitvoeren.<\/p>\n<p>Er zijn nog een paar dingen om in gedachten te houden bij het gebruik van deze operator, voornamelijk:<\/p>\n<ul>\n<li>Je kunt geen <code>$where<\/code> expression specificeren in een <code>$elemMatch<\/code> bewerking.<\/li>\n<li>Je kunt geen <code>$text<\/code> query expression specificeren in een <code>$elemMatch<\/code> operatie.<\/li>\n<\/ul>\n<p>We hebben bijvoorbeeld de volgende documenten in de verzameling leerlingresultaten:<\/p>\n<pre><code class=\"language-php\">{ _id: 1, results: [ 92, 89, 98 ] }\n{ _id: 2, results: [ 85, 99, 99 ] }<\/code><\/pre>\n<p>De volgende query komt alleen overeen met die documenten waarvan de resultaten-array ten minste \u00e9\u00e9n element bevat dat zowel groter dan of gelijk is aan 90 als kleiner is dan 95:<\/p>\n<pre><code class=\"language-php\">db.studentresults.find(  { results: { $elemMatch: { $gte: 90, $lt: 95 } } })<\/code><\/pre>\n<p>Onze query levert het volgende document op, omdat het element 92 zowel groter dan of gelijk is aan 90 als kleiner is dan 95:<\/p>\n<pre><code class=\"language-php\">{ \"_id\" : 1, \"results\" :[ 92, 89, 98 ] }<\/code><\/pre>\n<h4>$size<\/h4>\n<p>De operator <code>$size<\/code> geeft die documenten terug waarvan de grootte van de matrix overeenkomt met het aantal elementen dat in het argument is opgegeven:<\/p>\n<pre><code class=\"language-php\">{ field: { $size: value } }<\/code><\/pre>\n<p>Hier volgt een voorbeeld:<\/p>\n<pre><code class=\"language-php\">db.collection.find( { field: { $size: 2 } });<\/code><\/pre>\n<p>Dit zou alle documenten in de opgegeven verzameling teruggeven waarbij het veld een array is met 2 elementen: <code>{ field: [ orange, apple] }<\/code> en <code>{ field: [ blue, red] }<\/code>, maar niet <code>{ field: blue}<\/code> of <code>{ field: [ raspberry, lemon, grapefruit ] }<\/code>.<\/p>\n<p>Maar terwijl we de specifieke waarde kunnen invoeren als de grootte, kunnen we geen bereiken van waarden opgeven als de grootte.<\/p>\n<h3>Geospatiale operators<\/h3>\n<p>Met MongoDB kun je geospatiale gegevens opslaan in de vorm van GeoJSON types. GeoJSON is een open-standaard indeling gebaseerd op de JavaScript object notatie dat geografische kenmerken kan weergeven en niet-ruimtelijke attributen kan ondersteunen. Er zijn twee soorten geospatiale operators waar we het in dit artikel over zullen hebben: geometriespecificaties en query selectors.<\/p>\n<h4>$geometry<\/h4>\n<p>Deze operator vermeldt GeoJSON geometrie voor gebruik met de volgende ruimtelijke query operators: <code>$geoIntersects<\/code>, <code>$geoWithin<\/code>,<code>$nearSphere<\/code>, en <code>$near<\/code>. <code>$geometry<\/code> maakt gebruik van EPSG:4326 als standaard co\u00f6rdinaatreferentiesysteem (CRS).<\/p>\n<p>Om GeoJSON objecten met het standaard CRS te vermelden, kun je gebruik maken van het volgende fragment voor <code>$geometry<\/code>:<\/p>\n<pre><code class=\"language-php\">$geometry: {\n   type: \"&lt;GeoJSON object type&gt;\",\n   coordinates: [ &lt;coordinates&gt; ]\n}<\/code><\/pre>\n<p>Om een GeoJSON single-ringed polygon te mentionen met een tailored MongoDB CRS, kun je het volgende fragment gebruiken (je kunt dit alleen gebruiken voor <code>$geoWithin<\/code> en <code>$geoIntersects<\/code>):<\/p>\n<pre><code class=\"language-php\">$geometry: {\n   type: \"Polygon\",\n   coordinates: [ &lt;coordinates&gt; ],\n   crs: {\n      type: \"name\",\n      properties: { name: \"urn:x-mongodb:crs:strictwinding:EPSG:4326\" }\n   }\n}<\/code><\/pre>\n<h4>$polygon<\/h4>\n<p>De <code>$polygon<\/code> operator kan worden gebruikt om een polygon te specificeren voor een geospatiale <code>$geoWithin<\/code> query op oude co\u00f6rdinatenparen. Deze query geeft dan paren terug die binnen de grenzen van de polygon vallen. Echter,<code> $polygon<\/code> zal geen GeoJSON objecten query&#8217;en. Om een polygon te defini\u00ebren, moet je een array van co\u00f6rdinaatpunten specificeren, als volgt:<\/p>\n<pre><code class=\"language-php\">{\n   : {\n      $geoWithin: {\n         $polygon: [ [ &lt;x1&gt; , &lt;y1&gt; ], [ &lt;x2&gt; , &lt;y2&gt; ], [ &lt;x3&gt; , &lt;y3&gt; ], ... ]\n      }\n   }\n}<\/code><\/pre>\n<p>Hier is het laatste punt impliciet verbonden met het eerste. Je kunt zoveel punten of zijden opgeven als je wilt.<\/p>\n<p>De volgende query geeft bijvoorbeeld alle documenten met co\u00f6rdinaten binnen de polygon gedefinieerd door [0,0], [1,5], en [3,3]:<\/p>\n<pre><code class=\"language-php\">db.places.find(\n  {\n     loc: {\n       $geoWithin: { $polygon: [ [ 0 , 0 ], [ 1 , 5 ], [ 3 , 3 ] ] }\n     }\n  }\n)<\/code><\/pre>\n<h4>$geoWithin<\/h4>\n<p>Deze operator kan worden gebruikt om documenten met geospatiale gegevens te kiezen die volledig binnen een specifieke vorm liggen. De gespecificeerde vorm kan een GeoJSON polygon zijn, een GeoJSON polygon (met meerdere ringen of met \u00e9\u00e9n ring), of een vorm die kan worden gedefinieerd door oude co\u00f6rdinatenparen.<\/p>\n<p>De <code>$geoWithin<\/code> operator maakt gebruik van de <code>$geometry<\/code> operator om het GeoJSON object te noemen.<\/p>\n<p>Om de GeoJSON multipolygons of polygons via het standaard co\u00f6rdinatenreferentiesysteem (CRS) te vermelden, kun je de onderstaande syntaxis gebruiken:<\/p>\n<pre><code class=\"language-php\">{\n   : {\n      $geoWithin: {\n         $geometry: {\n            type: &lt;\"Polygon\" or \"MultiPolygon\"&gt; ,\n            coordinates: [ &lt;coordinates&gt; ]\n         }\n      }\n   }\n}<\/code><\/pre>\n<p>Voor <code>$geoWithin<\/code> queries die de GeoJSON geometrie\u00ebn vermelden met oppervlakten groter dan een enkele hemisfeer, zou het gebruik van het standaard CRS leiden tot queries voor de complementaire geometrie\u00ebn.<\/p>\n<p>Om een GeoJSON polygon met \u00e9\u00e9n enkele ring te mentionen met een custom MongoDB CRS, kun je gebruik maken van het hieronder genoemde prototype in de <code>$geometry<\/code> expression:<\/p>\n<pre><code class=\"language-php\">{\n   : {\n      $geoWithin: {\n         $geometry: {\n           type: \"Polygon\" ,\n           coordinates: [ &lt;coordinates&gt; ],\n           crs: {\n              type: \"name\",\n              properties: { name: \"urn:x-mongodb:crs:strictwinding:EPSG:4326\" }\n           }\n         }\n      }\n   }\n}<\/code><\/pre>\n<p>Het volgende voorbeeld kiest alle loc-gegevens die volledig binnen een GeoJSON polygon bestaan, waarbij de oppervlakte van de polygoon kleiner is dan de oppervlakte van een enkele hemisfeer:<\/p>\n<pre><code class=\"language-php\">db.places.find(\n   {\n     loc: {\n       $geoWithin: {\n          $geometry: {\n             type : \"Polygon\" ,\n             coordinates: [ [ [ 0, 0 ], [ 3, 6 ], [ 6, 1 ], [ 0, 0 ] ] ]\n          }\n       }\n     }\n   }\n)<\/code><\/pre>\n<h4>$box<\/h4>\n<p>Je kunt <code>$box<\/code> gebruiken om een rechthoek te specificeren voor een geospatiale <code>$geoWithin<\/code> query om documenten te leveren die binnen de grenzen van de rechthoek liggen, volgens hun puntgebaseerde locatiegegevens. Als je <code>$geoWithin<\/code> gebruikt met de <code>$box<\/code>, krijg je documenten gebaseerd op de co\u00f6rdinaten van de query. In dit scenario vraagt <code>$geoWithin<\/code> geen GeoJSON vormen op.<\/p>\n<p>Om de <code>$box<\/code> operator te gebruiken, moet je de rechterbovenhoek en de linkeronderhoek van de rechthoek vermelden in een array object:<\/p>\n<pre><code class=\"language-php\">{ &lt;location field&gt; : { $geoWithin: { $box: [ [ &lt;bottom left coordinates&gt; ],\n [ &lt;upper right coordinates&gt; ] ] } } }<\/code><\/pre>\n<p>De bovengenoemde query berekent de afstand door gebruik te maken van vlakke geometrie. De volgende query geeft alle documenten die binnen de box liggen met punten op: [0,0], [0,30], [30,0], [30,30]:<\/p>\n<pre><code class=\"language-php\">db.places.find ( { \n loc: { $geoWithin: { $box: [ [ 0,0 ], [ 30,30 ] ] } }\n} )<\/code><\/pre>\n<h4>$nearSphere<\/h4>\n<p>Je kunt <code>$nearSphere<\/code> gebruiken om een punt te noemen waarvoor een geospatiale query de documenten teruggeeft van het dichtstbijzijnde naar het verste.<\/p>\n<p>MongoDB gebruikt sferische geometrie om de afstanden te berekenen voor <code>$nearSphere<\/code>. Het zal een geospatiale index nodig hebben, als volgt:<\/p>\n<ol>\n<li>2d index voor locatiegegevens beschreven als legale co\u00f6rdinatenparen. Om een 2d index op GeoJSON punten te gebruiken, moet je de index genereren op het co\u00f6rdinatenveld van het GeoJSON object.<\/li>\n<li>2d index voor locatiegegevens beschreven als GeoJSON punten.<\/li>\n<\/ol>\n<p>Om een GeoJSON punt te noemen, kun je gebruik maken van de volgende syntaxis:<\/p>\n<pre><code class=\"language-php\">{\n  $nearSphere: {\n     $geometry: {\n        type : \"Point\",\n        coordinates : [ &lt;longitude&gt;, &lt;latitude&gt; ]\n     },\n     $minDistance: &lt;distance in meters&gt;,\n     $maxDistance: &lt;distance in meters&gt; \n  }\n}<\/code><\/pre>\n<p>Hier zijn <code>$minDistance<\/code> en <code>$maxDistance<\/code> optioneel. <code>$minDistance<\/code> kan de resultaten beperken tot de documenten die zich minstens op de opgegeven afstand van het centrum bevinden. Je kunt <code>$maxDistance<\/code> gebruiken voor beide indexen.<\/p>\n<p>Beschouw nu een verzameling &#8220;plaatsen&#8221; die bestaat uit documenten met een location veld dat een 2dsphere index heeft. Het volgende voorbeeld zou de punten opleveren waarvan de locatie ten minste 2.000 meter en ten hoogste 6.000 meter van het door jou gekozen punt ligt, gerangschikt van dichtstbijzijnde naar verste:<\/p>\n<pre><code class=\"language-php\">db.places.find(\n   {\n     location: {\n        $nearSphere: {\n           $geometry: {\n              type : \"Point\",\n              coordinates : [ -43.9532, 50.32 ]\n           },\n           $minDistance: 2000,\n           $maxDistance: 6000\n        }\n     }\n   }\n)<\/code><\/pre>\n<h4>$geoIntersects<\/h4>\n<p>Met de operator <code>$geoIntersects<\/code> kun je documenten selecteren waarvan de geospatiale gegevens een bepaald GeoJSON object snijden (d.w.z. waar de convergentie van het gespecificeerde object en de gegevens niet leeg is). Het maakt gebruik van de <code>$geometry<\/code> operator om het GeoJSON object te specificeren.<\/p>\n<p>Om GeoJSON multipolygonen of polygonen via het standaard co\u00f6rdinaatreferentiesysteem (CRS) te vermelden, kun je de volgende syntaxis gebruiken:<\/p>\n<pre><code class=\"language-php\">{ &lt;location field&gt;: {\n     $geoIntersects: {\n        $geometry: {\n           type: \"&lt;GeoJSON object type&gt;\" ,\n           coordinates: [ &lt;coordinates&gt; ]\n        }\n     }\n  }\n}<\/code><\/pre>\n<p>De volgende instantie zal <code>$geoIntersects<\/code> gebruiken om alle loc-gegevens te kiezen die snijden met de polygon beschreven door de co\u00f6rdinaten-array:<\/p>\n<pre><code class=\"language-php\">db.places.find(\n   {\n     loc: {\n       $geoIntersects: {\n          $geometry: {\n             type: \"Polygon\" ,\n             coordinates: [\n               [ [ 0, 0 ], [ 2, 6 ], [ 4, 1 ], [ 0, 0 ] ]\n             ]\n          }\n       }\n     }\n   }\n)<\/code><\/pre>\n<h4>$center<\/h4>\n<p>De operator <code>$center<\/code> noemt een cirkel voor een <code>$geoWithin<\/code> query die legacy co\u00f6rdinatenparen retourneert die binnen de grenzen van de cirkel liggen.<\/p>\n<p><code>$center<\/code> geeft geen GeoJSON objecten terug. Om gebruik te maken van de <code>$center<\/code> operator moet je een array specificeren die bevat:<\/p>\n<ol>\n<li>De straal van de cirkel, zoals gemeten in de door het co\u00f6rdinatensysteem gebruikte eenheden.<\/li>\n<li>De rasterco\u00f6rdinaten van het middelpunt van de cirkel.<\/li>\n<\/ol>\n<pre><code class=\"language-php\">{\n  &lt;location field&gt; : {\n      $geoWithin: { $center: [ [ &lt;x&gt; , &lt;y&gt; ] , &lt;radius&gt; ] }\n   }\n}<\/code><\/pre>\n<p>Het onderstaande voorbeeld geeft alle documenten met co\u00f6rdinaten die gevonden kunnen worden binnen de cirkel met het middelpunt op [2,3] en een straal van 40:<\/p>\n<pre><code class=\"language-php\">db.places.find(\n   { loc: { $geoWithin: { $center: [ [2, 3], 40 ] } } }\n)<\/code><\/pre>\n<h3>Projectie operators<\/h3>\n<p>Je kunt projectie operators gebruiken om de velden te noemen die door een operatie worden geretourneerd. Met MongoDB projectie operators kan de <code>find()<\/code> functie worden gebruikt met argumenten voor het filteren van gegevens. Dit helpt gebruikers om alleen de vereiste gegevensvelden uit een document te halen. Je kunt er dus transparante en beknopte gegevens mee projecteren zonder de algehele databaseprestaties aan te tasten.<\/p>\n<h4>$elemMatch (projectie)<\/h4>\n<p>De operator <code>$elemMatch<\/code> is verantwoordelijk voor het beperken van de inhoud van een veld uit de query-resultaten tot alleen het eerste element dat overeenkomt met de voorwaarde <code>$elemMatch<\/code>.<\/p>\n<p>Hier zijn een paar dingen die je in gedachten moet houden voordat je <code>$elemMatch<\/code> gebruikt:<\/p>\n<ul>\n<li>Vanaf MongoDB 4.4 retourneert de <code>$elemMatch<\/code> projectie van een bestaand veld, ongeacht de volgorde van de velden in het document, het veld dat volgt op de opname van andere bestaande velden.<\/li>\n<li>Zowel de <code>$elemMatch<\/code> als de <code>$<\/code> operator projecteren het eerste overeenkomende element uit een array op basis van een gespecificeerde voorwaarde. De <code>$<\/code> operator zou het eerste overeenkomende array-element projecteren van elk document in een verzameling op basis van een voorwaarde uit het query statement, terwijl de <code>$elemMatch<\/code> projectie operator een expliciet condition argument neemt. Hiermee kun je projecteren op basis van een voorwaarde die niet in de query voorkomt, of als je moet projecteren op basis van verschillende velden in de embedded documenten van de array.<\/li>\n<\/ul>\n<p>Je moet je ook bewust zijn van de volgende beperkingen voordat je de <code>$elemMatch<\/code> operator op je gegevens gebruikt:<\/p>\n<ul>\n<li>Je kunt geen <code>$text<\/code> query-expression noemen binnen een <code>$elemMatch<\/code> operator.<\/li>\n<li><code>db.collection.find()<\/code> bewerkingen op views ondersteunen de <code>$elemMatch<\/code> projectie operator niet.<\/li>\n<\/ul>\n<p>Het volgende voorbeeld over de <code>$elemMatch<\/code> projectie operator gaat uit van een collectie <code>schools<\/code> met de volgende documenten:<\/p>\n<pre><code class=\"language-php\">{\n _id: 1,\n zipcode: \"63108\",\n students: [\n              { name: \"mark\", school: 102, age: 9 },\n              { name: \"geoff\", school: 101, age: 13 },\n              { name: \"frank\", school: 104, age: 12 }\n           ]\n}\n{\n _id: 2,\n zipcode: \"63110\",\n students: [\n              { name: \"harry\", school: 103, age: 14 },\n              { name: \"george\", school: 103, age: 7 },\n           ]\n}\n{\n _id: 3,\n zipcode: \"63108\",\n students: [\n              { name: \"harry\", school: 103, age: 14 },\n              { name: \"george\", school: 103, age: 7 },\n           ]\n}\n{\n _id: 4,\n zipcode: \"63110\",\n students: [\n              { name: \"jim\", school: 103, age: 9 },\n              { name: \"michael\", school: 103, age: 12 },\n           ]\n}<\/code><\/pre>\n<p>In dit geval vraagt de <code>find()<\/code> bewerking naar alle documenten waarin de waarde van het veld postcode 63110 is. De <code>$elemMatch<\/code> projectie zou alleen het eerste overeenkomende element van de <code>students<\/code> array teruggeven waar het veld <code>school<\/code> de waarde 103 heeft:<\/p>\n<pre><code class=\"language-php\">db.schools.find( { zipcode: \"63110\" },\n                 { students: { $elemMatch: { school: 103 } } } )<\/code><\/pre>\n<p>Zo zou het resultaat eruit zien:<\/p>\n<pre><code class=\"language-php\">{ \"_id\" : 2, \"students\" : [ { \"name\" : \"harry\", \"school\" : 103, \"age\" : 14 } ] }\n{ \"_id\" : 4, \"students\" : [ { \"name\" : \"jim\", \"school\" : 103, \"age\" : 9 } ] }<\/code><\/pre>\n<h4>$slice (projectie)<\/h4>\n<p>De operator <code>$slice<\/code> projectie kan worden gebruikt om het aantal elementen in een array op te geven dat in het query-resultaat moet worden teruggegeven:<\/p>\n<pre><code class=\"language-php\">db.collection.find(\n   &lt;query&gt; ,\n   { &lt;arrayField&gt; : { $slice: &lt;number&gt; } }\n);<\/code><\/pre>\n<p>Het kan ook op deze manier worden uitgedrukt:<\/p>\n<pre><code class=\"language-php\">db.collection.find(\n  &lt;query&gt; ,\n   { &lt;arrayField&gt; : { $slice: [ &lt;number&gt; , &lt;number&gt; ] } }\n);<\/code><\/pre>\n<p>Om hetzelfde te demonstreren kun je een voorbeeldverzameling van tweets maken met de volgende documenten:<\/p>\n<pre><code class=\"language-php\">db.posts.insertMany([\n   {\n     _id: 1,\n     title: \"Nuts are not blueberries.\",\n     comments: [ { comment: \"0. true\" }, { comment: \"1. blueberries aren't nuts.\"} ]\n   },\n   {\n     _id: 2,\n     title: \"Coffee please.\",\n     comments: [ { comment: \"0. Indubitably\" }, { comment: \"1. Cuppa tea please\" }, { comment: \"2. frappucino\" }, { comment: \"3. Mocha latte\" }, { comment: \"4. whatever\" } ]\n   }\n])<\/code><\/pre>\n<p>De volgende bewerking zou de <code>$slice<\/code> projectie operator gebruiken op de tweets array om de array met zijn eerste twee elementen terug te geven. Als een array minder dan twee elementen bevat, worden alle elementen in de array teruggegeven:<\/p>\n<pre><code class=\"language-php\">db.posts.find( {}, { comments: { $slice: 2 } } )<\/code><\/pre>\n<p>Die bewerking zou de volgende documenten teruggeven:<\/p>\n<pre><code class=\"language-php\">{\n   \"_id\" : 1,\n   \"title\" : \"Nuts are not blueberries.\",\n   \"comments\" : [ { \"comment\" : \"0. true\" }, { \"comment\" : \"1. blueberries aren't nuts.\" } ]\n}\n{\n   \"_id\" : 2,\n   \"title\" : \"Coffee please.\",\n   \"comments\" : [ { \"comment\" : \"0. Indubitably\" }, { \"comment\" : \"1. Cuppa tea please\" } ]\n}<\/code><\/pre>\n<h4>$ (projectie)<\/h4>\n<p>De positionele operator <code>$<\/code> beperkt de inhoud van een array om het eerste element terug te geven dat overeenkomt met de zoekvoorwaarde van die array. Je kunt <code>$<\/code> gebruiken in het projectiedocument van de methode <code>find()<\/code> of de methode <code>findOne()<\/code> als je slechts \u00e9\u00e9n bepaald array-element in gekozen documenten nodig hebt.<\/p>\n<p>Zo ziet de syntaxis voor de <code>$<\/code> operator eruit:<\/p>\n<pre><code class=\"language-php\">db.collection.find( { &lt;array&gt;: &lt;condition&gt; ... },\n                    { \"&lt;array&gt;.$\": 1 } )\ndb.collection.find( { &lt;array.field&gt;: &lt;condition&gt; ...},\n                    { \"&lt;array&gt;.$\": 1 } )<\/code><\/pre>\n<p>In dit voorbeeld bestaat de verzameling <code>students<\/code> uit de volgende documenten:<\/p>\n<pre><code class=\"language-php\">{ \"_id\" : 1, \"semester\" : 2, \"grades\" : [ 75, 67, 93 ] }\n{ \"_id\" : 2, \"semester\" : 2, \"grades\" : [ 60, 68, 72 ] }\n{ \"_id\" : 3, \"semester\" : 2, \"grades\" : [ 95, 82, 67 ] }\n{ \"_id\" : 4, \"semester\" : 3, \"grades\" : [ 89, 95, 70 ] }\n{ \"_id\" : 5, \"semester\" : 3, \"grades\" : [ 68, 98, 82 ] }\n{ \"_id\" : 6, \"semester\" : 3, \"grades\" : [ 65, 70, 76 ] }<\/code><\/pre>\n<p>In de volgende query retourneert de projectie <code>{ \"grades.$\": 1 }<\/code> alleen het eerste element groter dan of gelijk aan 89 voor het veld <code>grades<\/code>:<\/p>\n<pre><code class=\"language-php\">db.students.find( { semester: 2, grades: { $gte: 89 } },\n                  { \"grades.$\": 1 } )<\/code><\/pre>\n<p>Deze bewerking levert de volgende documenten op:<\/p>\n<pre><code class=\"language-php\">{\"_id\": 1, \"grades\": [93] }<\/code><\/pre>\n<h3>Evaluatie operators<\/h3>\n<p>Je kunt MongoDB evaluatie operators gebruiken om de algemene gegevensstructuur of individuele velden in een document te meten.<\/p>\n<p>Laten we eens kijken naar enkele veel voorkomende MongoDB evaluatie operators.<\/p>\n<h4>$mod<\/h4>\n<p>Je kunt deze operator gebruiken om documenten te matchen waar de waarde van een gespecificeerd veld gelijk is aan de rest na gedeeld te zijn door een gespecificeerde waarde:<\/p>\n<pre><code class=\"language-php\">{ field: { $mod: [ divisor, remainder ] } }<\/code><\/pre>\n<p>Stel je hebt een tabel met auto&#8217;s van verschillende merken die je in je showroom hebt staan. De volgende query zou je alle automerken geven waarvan het voorraadnummer een veelvoud is van 250.<\/p>\n<pre><code class=\"language-php\">db.cars.find ( { qty: { $mod: [ 250,0 ] } } )<\/code><\/pre>\n<h4>$jsonSchema<\/h4>\n<p>Met <code>$jsonSchema<\/code> kun je de documenten matchen die overeenkomen met het opgegeven JSON schema. MongoDB&#8217;s implementatie van het JSON schema bevat de toevoeging van het <code>bsonType<\/code> keyword, waarmee je alle BSON types kunt gebruiken binnen de <code>$jsonSchema<\/code> operator.<\/p>\n<p><code>bsonType<\/code> kan dezelfde string aliassen accepteren die je zou gebruiken voor de <code>type<\/code> operator. Zo zou <code>$jsonSchema<\/code>&#8217;s syntax eruit zien:<\/p>\n<pre><code class=\"language-php\">{ $jsonSchema: &lt;JSON Schema object&gt; }<\/code><\/pre>\n<p>Hier is het JSON schema object geformatteerd op basis van <a href=\"https:\/\/tools.ietf.org\/html\/draft-zyp-json-schema-04\">het ontwerp 4 van de JSON schema standaard<\/a>:<\/p>\n<pre><code class=\"language-php\">{ &lt;keyword1&gt;: &lt;value1&gt;, ... }<\/code><\/pre>\n<p>Hier is een voorbeeld om te demonstreren hoe <code>$jsonSchema<\/code> werkt:<\/p>\n<pre><code class=\"language-php\">{ $jsonSchema: {\n     required: [ \"name\", \"major\", \"gpa\", \"address\" ],\n     properties: {\n        name: {\n           bsonType: \"string\",\n           description: \"must be a string and is required\"\n        },\n        address: {\n           bsonType: \"object\",\n           required: [ \"zipcode\" ],\n           properties: {\n               \"street\": { bsonType: \"string\" },\n               \"zipcode\": { bsonType: \"string\" }\n           }\n        }\n     }\n  }\n}<\/code><\/pre>\n<p>Je kunt <code>$jsonSchema<\/code> ook gebruiken in een documentvalidator om het opgegeven schema af te dwingen bij update- en invoegbewerkingen:<\/p>\n<pre><code class=\"language-php\">db.createCollection(&lt;collection&gt; , { validator: { $jsonSchema: &lt;schema&gt; } } )\ndb.runCommand( { collMod: &lt;collection&gt;, validator:{ $jsonSchema: &lt;schema&gt; } } )<\/code><\/pre>\n<p>Bedenk dat er verschillende zaken zijn die niet ondersteund worden door de <code>$jsonSchema<\/code> operator:<\/p>\n<ol>\n<li>Het integer type. Je moet het BSON type long of int gebruiken met het bsonType keyword.<\/li>\n<li>Onbekende keywords.<\/li>\n<li>Het koppelen van properties en de hypermedia van JSON schema, samen met het gebruik van JSON referenties en JSON pointers.<\/li>\n<\/ol>\n<h4>$text<\/h4>\n<p>De operator <code>$text<\/code> zoekt naar een tekst binnen de inhoud van het opgegeven veld, ge\u00efndexeerd met een text index:<\/p>\n<pre><code class=\"language-php\">{  \n  $text:  \n    {  \n      $search: &lt;string&gt;,  \n      $language: &lt;string&gt;,  \n      $caseSensitive: &lt;boolean&gt;,  \n      $diacriticSensitive: &lt;boolean&gt;   \n    }  \n}<\/code><\/pre>\n<p>In dit geval zal het volgende codefragment de tabel doorzeven om alle auto&#8217;s met de tekst &#8220;Porsche&#8221; erin uit te filteren:<\/p>\n<pre><code class=\"language-php\">db.cars.find( { $text: { $search: \"Porsche\" } } )<\/code><\/pre>\n<h4>$regex<\/h4>\n<p>De operator <code>$regex<\/code> biedt mogelijkheden voor reguliere expressions om patroonmatches in queries toe te passen. MongoDB maakt gebruik van reguliere expressions die compatibel zijn met Perl:<\/p>\n<pre><code class=\"language-php\">{&lt;field&gt; : \/pattern\/ &lt;options&gt;}<\/code><\/pre>\n<p>Het volgende voorbeeld zou helpen om alle auto&#8217;s uit te filteren waar de string &#8220;$78900&#8221; in voorkomt:<\/p>\n<pre><code class=\"language-php\">db.cars.find( { price: { $regex: \/$78900\/ } } )<\/code><\/pre>\n<h4>$expr<\/h4>\n<p>Met de operator <code>$expr<\/code> kun je aggregatie-expressions gebruiken in de querytaal:<\/p>\n<pre><code class=\"language-php\">{ $expr: { &lt;expression&gt; } }<\/code><\/pre>\n<p>Je kunt ook <code>$expr<\/code> gebruiken om query-expressions te bouwen die velden uit hetzelfde document vergelijken in een <code>$match<\/code> stadium. Als de <code>$match<\/code> stap toevallig deel uitmaakt van een <code>$lookup<\/code> stap, kan <code>$expr<\/code> velden vergelijken met behulp van let variabelen.<\/p>\n<h4>$where<\/h4>\n<p>Je kunt de <code>$where<\/code> operator gebruiken om een string met een volledige JavaScript functie of een JavaScript expression door te geven aan het query systeem. De <code>$where<\/code> operator biedt meer flexibiliteit, maar vereist dat de database de JavaScript functie of expression verwerkt voor elk document in de collectie. Je kunt naar dit document verwijzen in de JavaScript functie of expression door <code>obj<\/code> of <code>this<\/code> te gebruiken.<\/p>\n<p>Hier is een voorbeeld van de syntaxis:<\/p>\n<pre><code class=\"language-php\">{ $where: &lt;string|JavaScript Code&gt; }<\/code><\/pre>\n<p>Er zijn een paar belangrijke overwegingen om in gedachten te houden voordat we in een voorbeeld duiken tijdens het gebruik van de <code>$where<\/code> operator:<\/p>\n<ul>\n<li>Je moet de <code>$where<\/code> query operator alleen gebruiken voor documenten op het hoogste niveau. De <code>$where<\/code> query operator werkt niet in een nested document, zoals in een <code>$elemMatch<\/code> query.<\/li>\n<li>In het algemeen moet je <code>$where<\/code> alleen gebruiken als je je query niet via een andere operator kunt uitdrukken. Als je <code>$where<\/code> moet gebruiken, zorg er dan voor dat je tenminste \u00e9\u00e9n andere standaard query operator toevoegt om de resultatenverzameling te filteren. Onafhankelijk gebruik van <code>$where<\/code> vereist een verzamelscan voor een goede uitvoering.<\/li>\n<\/ul>\n<p>Hier is een voorbeeld om dit te illustreren:<\/p>\n<pre><code class=\"language-php\">db.cars.find( { $where: function() {  \n   return (hex_md5(this.name)== \"9a43e617b50cd379dca1bc6e2a8\")  \n} } );<\/code><\/pre>\n<h3>Bitwise operators<\/h3>\n<p>Bitwise operators geven gegevens terug op basis van bitpositievoorwaarden. Eenvoudig gezegd worden ze gebruikt om numerieke of binaire waarden te matchen waarin elke bit van een set bitposities de waarde 1 of 0 heeft.<\/p>\n<h4>$bitsAllSet<\/h4>\n<p>Deze operator komt overeen met alle documenten waarin alle door de query opgegeven bitposities in het veld zijn ingesteld (d.w.z. 1):<\/p>\n<pre><code class=\"language-php\">{ &lt;field&gt; : { $bitsAllSet: &lt;numeric bitmask&gt; } }<\/code><\/pre>\n<pre><code class=\"language-php\">{ &lt;field&gt; : { $bitsAllSet: &lt; BinData bitmask&gt; } }<\/code><\/pre>\n<pre><code class=\"language-php\">{ &lt;field&gt; : { $bitsAllSet: [ &lt;position1&gt; , &lt;position2&gt; , ... ] } }<\/code><\/pre>\n<p>De veldwaarde moet ofwel een BinData instantie of numeriek zijn voor <code>$bitsAllSet<\/code> om overeen te komen met het huidige document.<\/p>\n<p>In het volgende voorbeeld maken we gebruik van een verzameling met de volgende documenten:<\/p>\n<pre><code class=\"language-php\">db.collection.save({ _id: 1, a: 54, binaryValueofA: \"00110110\" })\ndb.collection.save({ _id: 2, a: 20, binaryValueofA: \"00010100\" })\ndb.collection.save({ _id: 3, a: 20.0, binaryValueofA: \"00010100\" })\ndb.collection.save({ _id: 4, a: BinData(0, \"Zg==\"), binaryValueofA: \"01100110\" })<\/code><\/pre>\n<p>De hieronder genoemde query zal de <code>$bitsAllSet<\/code> operator gebruiken om te testen of veld a bits heeft ingesteld op positie 1 en positie 5, waarbij de minst significante bit op positie 0 zou staan:<\/p>\n<pre><code class=\"language-php\">db.collection.find( { a: { $bitsAllSet: [ 1, 5 ] } })<\/code><\/pre>\n<p>Deze query zou overeenkomen met de volgende documenten:<\/p>\n<pre><code class=\"language-php\">{ \"_id\" : 1, \"a\" : 54, \"binaryValueofA\" : \"00110110\" }\n{ \"_id\" : 4, \"a\" : BinData(0,\"Zg==\"), \"binaryValueofA\" : \"01100110\" }<\/code><\/pre>\n<h4>$bitsAllClear<\/h4>\n<p>De operator <code>$bitsAllClear<\/code> komt overeen met documenten waarin alle door de query opgegeven bitposities clear of <code>0<\/code> zijn:<\/p>\n<pre><code class=\"language-php\">{ &lt;field&gt; : { $bitsAllClear: &lt;numeric bitmask&gt; } }<\/code><\/pre>\n<pre><code class=\"language-php\">{ &lt;field&gt; : { $bitsAllClear: &lt; BinData bitmask&gt; } }<\/code><\/pre>\n<pre><code class=\"language-php\">{ &lt;field&gt; : { $bitsAllClear: [ &lt;position1&gt; , &lt;position2&gt; , ... ] } }<\/code><\/pre>\n<p>We gebruiken hier het voorbeeld van <code>$bitsAllSet<\/code> om het gebruik van <code>$bitsAllClear<\/code> te demonstreren. De volgende query zou deze operator gebruiken om te controleren of in veld a de bits op de posities 1 en 5 leeg zijn:<\/p>\n<pre><code class=\"language-php\">db.collection.find( { a: { $bitsAllClear: [ 1, 5 ] } } )<\/code><\/pre>\n<p>Deze query zou overeenkomen met de volgende documenten:<\/p>\n<pre><code class=\"language-php\">{ \"_id\" : 2, \"a\" : 20, \"binaryValueofA\" : \"00010100\" }\n{ \"_id\" : 3, \"a\" : 20, \"binaryValueofA\" : \"00010100\" }<\/code><\/pre>\n<h3>Meta operators<\/h3>\n<p>Er zijn verschillende query modifiers waarmee je het gedrag of de uitvoer van een query in MongoDB kunt wijzigen. De driver-interfaces kunnen cursormethoden bieden die ze voor jouw gebruik wrappen.<\/p>\n<h4>$hint<\/h4>\n<p>MongoDB deprecieerde <code>$hint<\/code> sinds v3.2. Maar deze operator kan nog steeds beschikbaar zijn voor MongoDB drivers zoals Go, Java, Scala, Ruby, Swift, enz. Het kan de query optimizer dwingen om een specifieke index te gebruiken om de query te fulfillen, die dan per document of per indexnaam kan worden genoemd.<\/p>\n<p>Je kunt de <code>$hint<\/code> operator ook gebruiken om indexeringsstrategie\u00ebn en queryprestaties te testen. Neem bijvoorbeeld de volgende bewerking:<\/p>\n<pre><code class=\"language-php\">db.users.find().hint( { age: 1 } )<\/code><\/pre>\n<p>Deze bewerking zou alle documenten binnen de verzameling genaamd <code>users<\/code> teruggeven door gebruik te maken van de index op het veld <code>age<\/code>.<\/p>\n<p>Je kunt ook een hint noemen door een van de volgende vormen te gebruiken:<\/p>\n<pre><code class=\"language-php\">db.users.find()._addSpecial( \"$hint\", { age : 1 } )\ndb.users.find( { $query: {}, $hint: { age : 1 } } )<\/code><\/pre>\n<p>Als er een indexfilter bestaat voor de queryvorm, zou MongoDB de <code>$hint<\/code> gewoon negeren.<\/p>\n<h4>$comment<\/h4>\n<p>Met de operator <code>$comment<\/code> kun je een comment toevoegen aan een query in elke context waarin <code>$query<\/code> kan voorkomen. Omdat comments propageren in het de profile log, kan het toevoegen van comments het interpreteren en traceren van je profiel vergemakkelijken.<\/p>\n<p>Je kunt <code>$comment<\/code> op drie manieren gebruiken:<\/p>\n<pre><code class=\"language-php\">db.collection.find( { &lt;query&gt; } )._addSpecial( \"$comment\", &lt;comment&gt; )\ndb.collection.find( { &lt;query&gt; } ).comment( &lt;comment&gt; )\ndb.collection.find( { $query: { &lt;query&gt; }, $comment: &lt;comment&gt; } )<\/code><\/pre>\n<p>Als je commentaar wilt toevoegen aan query expressions in andere contexten, zoals met <code>db.collection.update()<\/code>, maak dan gebruik van de <code>$comment<\/code> query operator in plaats van de meta operator.<\/p>\n<h4>$max<\/h4>\n<p>Je kunt een <code>$max<\/code> waarde noemen om de exclusieve bovengrens voor een bepaalde index te specificeren om de resultaten van <code>find()<\/code> te beperken. Deze operator specificeert de bovengrens voor alle sleutels van een specifieke volgorde in de index.<\/p>\n<p>Mongosh geeft je de volgende <code>max()<\/code> wrapper methode:<\/p>\n<pre><code class=\"language-php\">db.collection.find( { &lt;query&gt; } ).max( { field1: &lt;max value&gt; , ... fieldN: &lt;max valueN&gt; } )<\/code><\/pre>\n<p>Je kunt ook <code>$max<\/code> noemen met de volgende twee vormen:<\/p>\n<pre><code class=\"language-php\">db.collection.find( { &lt;query&gt; } )._addSpecial( \"$max\", { field1: &lt;max value1&gt; ,\n ... fieldN: &lt;max valueN&gt; } )\ndb.collection.find( { $query: { &lt;query&gt; }, $max: { field1: &lt;max value1&gt; ,\n ... fieldN: &lt;max valueN&gt; } } )<\/code><\/pre>\n<p>Als je bijvoorbeeld de exclusieve bovengrens wilt specificeren, houd dan rekening met de volgende bewerkingen op een verzameling met de naam verzameling die een index <code>{ age: 1 }<\/code> bevat:<\/p>\n<pre><code class=\"language-php\">db.collection.find( { &lt;query&gt; } ).max( { age: 100 } ).hint( { age: 1 } )<\/code><\/pre>\n<p>Deze bewerking beperkt de query tot die documenten waarin het veld leeftijd minder dan 100 is en dwingt een queryplan af dat de index <code>{ age: 1 }<\/code> scant van <code>minKey<\/code> tot 100.<\/p>\n<h4>$explain<\/h4>\n<p>Deze operator geeft informatie over het queryplan. Het geeft een document terug dat de indexen en processen beschrijft die gebruikt worden om de query te retourneren. Dit kan handig zijn als je een query probeert te optimaliseren.<\/p>\n<p>Je kunt de operator <code>$explain<\/code> in een van de volgende vormen noemen:<\/p>\n<pre><code class=\"language-php\">db.collection.find()._addSpecial( \"$explain\", 1 )\ndb.collection.find( { $query: {}, $explain: 1 } )<\/code><\/pre>\n<h2>Best practices voor MongoDB operators<\/h2>\n<p>In deze paragraaf bekijken we een paar van de best practices bij het gebruik van deze MongoDB operators.<\/p>\n<h3>Embedden en refereren<\/h3>\n<p>Embedden is een natuurlijke uitbreiding van datamodellering. Hiermee kun je application joins vermijden, wat updates en queries kan verminderen.<\/p>\n<p>Je kunt gegevens met een 1:1 relatie inbedden binnen een enkel document. Gegevens met een veel:1 relatie waarin &#8220;veel&#8221; objecten voorkomen met hun bovenliggende documenten kunnen echter ook goede kandidaten zijn.<\/p>\n<p>Het opslaan van dit soort gegevens in hetzelfde document lijkt een verstandige keuze. Embedden levert echter betere prestaties voor leesbewerkingen met dit soort gegevenslocaliteit.<\/p>\n<p>Gegevensmodellen die zijn embed kunnen ontwikkelaars ook helpen om geassocieerde gegevens in een enkele schrijfoperatie bij te werken. Dit werkt omdat het schrijven van een enkel document transactioneel is.<\/p>\n<p>Je zou het gebruik van referencing moeten overwegen voor de volgende scenario&#8217;s:<\/p>\n<ul>\n<li>Wanneer je een documentsegment bijwerkt en het steeds langer wordt, terwijl de rest van het document statisch is.<\/li>\n<li>Wanneer een document wordt opgevraagd, maar gegevens bevat die zelden worden gebruikt. Embedden zou de in-memory vereisten alleen maar vergroten, dus is referencing zinvoller.<\/li>\n<li>Wanneer de documentgrootte de MongoDB documentlimiet van 16MB overschrijdt. Dit kan gebeuren bij het modelleren van veel:1 relaties (bijvoorbeeld <em>medewerkers:afdeling)<\/em>.<\/li>\n<\/ul>\n<h3>Profilering en querypatronen onderzoeken<\/h3>\n<p>Voor de meeste ontwikkelaars is de eerste stap in het <a href=\"https:\/\/kinqsta.com\/nl\/blog\/tools-testen-performance\/\">optimaliseren van de prestaties<\/a> het begrijpen van de werkelijke en verwachte querypatronen. Als je de querypatronen van je applicatie goed genoeg kent, kun je je gegevensmodel maken en geschikte indices kiezen.<\/p>\n<p>MongoDB ontwikkelaars hebben toegang tot diverse krachtige hulpmiddelen waarmee ze de prestaties kunnen verbeteren. Maar dat betekent niet dat queryprofielen en patronen genegeerd kunnen worden.<\/p>\n<p>Een eenvoudige manier om de prestaties te verbeteren is bijvoorbeeld door je querypatronen te analyseren en te begrijpen waar je gegevens kunt embedden. Andere manieren om de prestaties van MongoDB te verbeteren na het identificeren van je belangrijkste querypatronen zijn:<\/p>\n<ul>\n<li>Ervoor zorgen dat je indices hebt op alle velden waartegen je query&#8217;s uitvoert.<\/li>\n<li>De resultaten van frequente subqueries op documenten opslaan om de leesbelasting te verminderen.<\/li>\n<li>In je logboeken kijken naar trage queries en dan je indexen controleren.<\/li>\n<\/ul>\n<h3>Gegevensindexering en -modellering herzien<\/h3>\n<p>Terwijl je je gegevensmodel maakt, beslis je hoe je relaties tussen gegevens gaat modelleren. Kiezen wanneer je een document embedt versus het maken van een reference over afzonderlijke documenten in verschillende verzamelingen, bijvoorbeeld, is een voorbeeld van een toepassingsspecifieke overweging.<\/p>\n<p>Een groot voordeel van JSON documenten is dat ze ontwikkelaars in staat stellen gegevens te modelleren op basis van de eisen van de toepassing. Door subdocumenten en arrays te nesten kun je complexe relaties tussen gegevens modelleren door gebruik te maken van eenvoudige tekstdocumenten.<\/p>\n<p>Je kunt MongoDB ook gebruiken om het volgende te modelleren:<\/p>\n<ul>\n<li>Geospatiale gegevens<\/li>\n<li>Tabulaire, platte en kolomstructuren<\/li>\n<li>Eenvoudige sleutel-waarde paren<\/li>\n<li>Tijdreeksgegevens<\/li>\n<li>Randen en knopen van verbonden grafiekgegevensstructuren en dergelijke<\/li>\n<\/ul>\n<h3>Sharding en replicatie monitoren<\/h3>\n<p>Replicatie kan cruciaal zijn voor het verbeteren van de prestaties, omdat het de beschikbaarheid van gegevens vergroot door horizontale schaling. Replicatie kan leiden tot betere prestaties en meer veiligheid door redundantie.<\/p>\n<p>Prestatiemonitoring kan gedoe opleveren, omdat dat extra middelen en tijd vergt om een soepele werking te garanderen. Je kunt gebruik maken van op de markt verkrijgbare tools voor prestatiemonitoring die aan je specifieke behoeften voldoen.<\/p>\n<p>Zo kan <a href=\"https:\/\/kinqsta.com\/nl\/apm-tool\/\">Kinsta APM<\/a> tijdgestampte informatie verzamelen over de MySQL databasequeries van je WordPress site, PHP processen, externe HTTP calls en nog veel meer. Je kunt deze gratis tool ook gebruiken om het volgende te debuggen:<\/p>\n<ul>\n<li>Lange API calls<\/li>\n<li>Lange externe URL queries<\/li>\n<li>Trage databasequeries, om er een paar te noemen.<\/li>\n<\/ul>\n<p>In MongoDB kan replicatie worden bereikt door middel van replicasets waarmee ontwikkelaars gegevens van een primaire node of server kunnen kopi\u00ebren over meerdere secondaries. Dit laat je replicatie sommige queries uitvoeren op secondaries in plaats van op de primary, waardoor contention wordt vermeden en een betere load balancing ontstaat.<\/p>\n<p>Sharded clusters in MongoDB zijn een andere manier om de prestaties te verbeteren. Net als replicatie kan sharding worden gebruikt om grote gegevenssets over meerdere servers te verdelen.<\/p>\n<p>Door gebruik te maken van een shard key kunnen ontwikkelaars shards of stukken data kopi\u00ebren over meerdere servers. Deze servers kunnen samenwerken om alle gegevens te gebruiken.<\/p>\n<p>Sharding heeft zo zijn voordelen, waaronder horizontale schaling voor schrijven\/lezen, hogere beschikbaarheid en grotere opslagcapaciteit.<\/p>\n<h3>Geheugengebruik bepalen<\/h3>\n<p>MongoDB presteert het best als de werkset van een toepassing (d.w.z. veelgebruikte gegevens en indices) zonder problemen in het geheugen past. Hoewel andere factoren bepalend zijn voor de prestaties, is de grootte van het RAMgeheugen het belangrijkst voor de grootte van de instantie.<\/p>\n<p>Als de werkset van een toepassing in het RAM past, moet de leesactiviteit van de schijf laag zijn. Maar als je werkset het RAM van de instance server of grootte overschrijdt, zal de leesactiviteit omhoog schieten.<\/p>\n<p>Als je dit ziet gebeuren, kun je het probleem misschien oplossen door over te stappen op een grotere instance met meer geheugen.<\/p>\n<h3>Plaats velden met meerdere waarden aan het eind<\/h3>\n<p>Als je een aantal velden indexeert, en een van de velden die je wilt query&#8217;en gebruikt een van die &#8220;multi-value&#8221; operators, dan moet je die aan het eind van de index zetten. Je moet de index zo rangschikken dat de opgevraagde velden voor exacte waarden eerst komen en de &#8220;multi-value&#8221; operators als laatste in de index.<\/p>\n<p>Een uitzondering hierop zou sorteren op de velden zijn. Plaats deze tussen de &#8220;multi-value&#8221; en exacte velden om de hoeveelheid in-memory sorteren die nodig is te verminderen.<\/p>\n<h2>Samenvatting<\/h2>\n<p>Voor MongoDB is snelheid cruciaal. Om queries snel terug te sturen, gebruikt MongoDB operators om wiskundige of logische taken uit te voeren. Kort door de bocht: het begrijpen van MongoDB operators is de sleutel tot het beheersen van MongoDB.<\/p>\n\n<p>Dit artikel belicht enkele van de belangrijkste MongoDB operators die je op je gegevens kunt gebruiken, zoals vergelijkingsoperators, logische operators, meta-operators en projectie-operators, om er een paar te noemen. Het helpt je ook begrijpen hoe je MongoDB operators kunt gebruiken en de best practices waarmee je er het meeste uit kunt halen.<\/p>\n<p>Welke van de operators gebruik jij het vaakst, en waarom? Deel het hieronder in de comments &#8211; we horen graag je gedachten!<\/p>\n","protected":false},"excerpt":{"rendered":"<p>In elk bedrijf zijn gegevens je grootste troef. Door gegevens te analyseren kun je beslissingen nemen over klantentrends en kan je gedrag voorspellen. Dit verhoogt de &#8230;<\/p>\n","protected":false},"author":117,"featured_media":45790,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_kinsta_gated_content":false,"_kinsta_gated_content_redirect":"","footnotes":""},"tags":[730,284,526,731,732],"topic":[884],"class_list":["post-45789","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","tag-datab","tag-database","tag-databases","tag-develpoment","tag-mongodb","topic-webdevelopment-tools"],"yoast_head":"<!-- This site is optimized with the Yoast SEO Premium plugin v24.6 (Yoast SEO v24.6) - https:\/\/yoast.com\/wordpress\/plugins\/seo\/ -->\n<title>9 soorten Mongodb operators die je moet kennen - Kinsta\u00ae<\/title>\n<meta name=\"description\" content=\"Dit artikel beschrijft de belangrijkste MongoDB operators die je kunnen helpen de prestaties te verbeteren en laat je zien hoe je ze kunt gebruiken.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/kinqsta.com\/nl\/blog\/mongodb-operators\/\" \/>\n<meta property=\"og:locale\" content=\"nl_NL\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"9 soorten Mongodb operators die je moet kennen\" \/>\n<meta property=\"og:description\" content=\"Dit artikel beschrijft de belangrijkste MongoDB operators die je kunnen helpen de prestaties te verbeteren en laat je zien hoe je ze kunt gebruiken.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/kinqsta.com\/nl\/blog\/mongodb-operators\/\" \/>\n<meta property=\"og:site_name\" content=\"Kinsta\u00ae\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/Kinsta-Nederland-476213452787823\/\" \/>\n<meta property=\"article:published_time\" content=\"2022-09-19T08:37:22+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2023-06-15T09:36:43+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/kinqsta.com\/nl\/wp-content\/uploads\/sites\/7\/2022\/09\/mongodb-operators.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"1460\" \/>\n\t<meta property=\"og:image:height\" content=\"730\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"Salman Ravoof\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:description\" content=\"Dit artikel beschrijft de belangrijkste MongoDB operators die je kunnen helpen de prestaties te verbeteren en laat je zien hoe je ze kunt gebruiken.\" \/>\n<meta name=\"twitter:image\" content=\"https:\/\/kinqsta.com\/nl\/wp-content\/uploads\/sites\/7\/2022\/09\/mongodb-operators.jpg\" \/>\n<meta name=\"twitter:creator\" content=\"@salmanravoof\" \/>\n<meta name=\"twitter:site\" content=\"@Kinsta_NL\" \/>\n<meta name=\"twitter:label1\" content=\"Geschreven door\" \/>\n\t<meta name=\"twitter:data1\" content=\"Salman Ravoof\" \/>\n\t<meta name=\"twitter:label2\" content=\"Geschatte leestijd\" \/>\n\t<meta name=\"twitter:data2\" content=\"36 minuten\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\/\/kinqsta.com\/nl\/blog\/mongodb-operators\/#article\",\"isPartOf\":{\"@id\":\"https:\/\/kinqsta.com\/nl\/blog\/mongodb-operators\/\"},\"author\":{\"name\":\"Salman Ravoof\",\"@id\":\"https:\/\/kinqsta.com\/nl\/#\/schema\/person\/9cafd2eedd617e640eeea4cf3a5fd987\"},\"headline\":\"9 soorten Mongodb operators die je moet kennen\",\"datePublished\":\"2022-09-19T08:37:22+00:00\",\"dateModified\":\"2023-06-15T09:36:43+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/kinqsta.com\/nl\/blog\/mongodb-operators\/\"},\"wordCount\":5469,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\/\/kinqsta.com\/nl\/#organization\"},\"image\":{\"@id\":\"https:\/\/kinqsta.com\/nl\/blog\/mongodb-operators\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/kinqsta.com\/nl\/wp-content\/uploads\/sites\/7\/2022\/09\/mongodb-operators.jpg\",\"keywords\":[\"datab\",\"database\",\"databases\",\"develpoment\",\"MongoDB\"],\"inLanguage\":\"nl-NL\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\/\/kinqsta.com\/nl\/blog\/mongodb-operators\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/kinqsta.com\/nl\/blog\/mongodb-operators\/\",\"url\":\"https:\/\/kinqsta.com\/nl\/blog\/mongodb-operators\/\",\"name\":\"9 soorten Mongodb operators die je moet kennen - Kinsta\u00ae\",\"isPartOf\":{\"@id\":\"https:\/\/kinqsta.com\/nl\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/kinqsta.com\/nl\/blog\/mongodb-operators\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/kinqsta.com\/nl\/blog\/mongodb-operators\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/kinqsta.com\/nl\/wp-content\/uploads\/sites\/7\/2022\/09\/mongodb-operators.jpg\",\"datePublished\":\"2022-09-19T08:37:22+00:00\",\"dateModified\":\"2023-06-15T09:36:43+00:00\",\"description\":\"Dit artikel beschrijft de belangrijkste MongoDB operators die je kunnen helpen de prestaties te verbeteren en laat je zien hoe je ze kunt gebruiken.\",\"breadcrumb\":{\"@id\":\"https:\/\/kinqsta.com\/nl\/blog\/mongodb-operators\/#breadcrumb\"},\"inLanguage\":\"nl-NL\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/kinqsta.com\/nl\/blog\/mongodb-operators\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"nl-NL\",\"@id\":\"https:\/\/kinqsta.com\/nl\/blog\/mongodb-operators\/#primaryimage\",\"url\":\"https:\/\/kinqsta.com\/nl\/wp-content\/uploads\/sites\/7\/2022\/09\/mongodb-operators.jpg\",\"contentUrl\":\"https:\/\/kinqsta.com\/nl\/wp-content\/uploads\/sites\/7\/2022\/09\/mongodb-operators.jpg\",\"width\":1460,\"height\":730},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/kinqsta.com\/nl\/blog\/mongodb-operators\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/kinqsta.com\/nl\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Webdevelopment tools\",\"item\":\"https:\/\/kinqsta.com\/nl\/onderwerpen\/webdevelopment-tools\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"9 soorten Mongodb operators die je moet kennen\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/kinqsta.com\/nl\/#website\",\"url\":\"https:\/\/kinqsta.com\/nl\/\",\"name\":\"Kinsta\u00ae\",\"description\":\"Snelle, veilige, premium hostingoplossingen\",\"publisher\":{\"@id\":\"https:\/\/kinqsta.com\/nl\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/kinqsta.com\/nl\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"nl-NL\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/kinqsta.com\/nl\/#organization\",\"name\":\"Kinsta\",\"url\":\"https:\/\/kinqsta.com\/nl\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"nl-NL\",\"@id\":\"https:\/\/kinqsta.com\/nl\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/kinqsta.com\/nl\/wp-content\/uploads\/sites\/7\/2023\/12\/kinsta-logo.jpeg\",\"contentUrl\":\"https:\/\/kinqsta.com\/nl\/wp-content\/uploads\/sites\/7\/2023\/12\/kinsta-logo.jpeg\",\"width\":500,\"height\":500,\"caption\":\"Kinsta\"},\"image\":{\"@id\":\"https:\/\/kinqsta.com\/nl\/#\/schema\/logo\/image\/\"},\"sameAs\":[\"https:\/\/www.facebook.com\/Kinsta-Nederland-476213452787823\/\",\"https:\/\/x.com\/Kinsta_NL\",\"https:\/\/www.instagram.com\/kinstahosting\/\",\"https:\/\/www.linkedin.com\/company\/kinsta\/\",\"https:\/\/www.pinterest.com\/kinstahosting\/\",\"https:\/\/www.youtube.com\/c\/Kinsta\"]},{\"@type\":\"Person\",\"@id\":\"https:\/\/kinqsta.com\/nl\/#\/schema\/person\/9cafd2eedd617e640eeea4cf3a5fd987\",\"name\":\"Salman Ravoof\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"nl-NL\",\"@id\":\"https:\/\/kinqsta.com\/nl\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/0c5885f75cb78473fb7408e5e49ad190?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/0c5885f75cb78473fb7408e5e49ad190?s=96&d=mm&r=g\",\"caption\":\"Salman Ravoof\"},\"description\":\"Salman Ravoof is a self-taught web developer, writer, creator, and a huge admirer of Free and Open Source Software (FOSS). Besides tech, he's excited by science, philosophy, photography, arts, cats, and food. Learn more about him on his website, and connect with Salman on Twitter.\",\"sameAs\":[\"https:\/\/salmanravoof.com\",\"https:\/\/www.linkedin.com\/in\/salman-ravoof-5a749133\/\",\"https:\/\/x.com\/salmanravoof\"],\"url\":\"https:\/\/kinqsta.com\/nl\/blog\/author\/salmanravoof\/\"}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"9 soorten Mongodb operators die je moet kennen - Kinsta\u00ae","description":"Dit artikel beschrijft de belangrijkste MongoDB operators die je kunnen helpen de prestaties te verbeteren en laat je zien hoe je ze kunt gebruiken.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/kinqsta.com\/nl\/blog\/mongodb-operators\/","og_locale":"nl_NL","og_type":"article","og_title":"9 soorten Mongodb operators die je moet kennen","og_description":"Dit artikel beschrijft de belangrijkste MongoDB operators die je kunnen helpen de prestaties te verbeteren en laat je zien hoe je ze kunt gebruiken.","og_url":"https:\/\/kinqsta.com\/nl\/blog\/mongodb-operators\/","og_site_name":"Kinsta\u00ae","article_publisher":"https:\/\/www.facebook.com\/Kinsta-Nederland-476213452787823\/","article_published_time":"2022-09-19T08:37:22+00:00","article_modified_time":"2023-06-15T09:36:43+00:00","og_image":[{"width":1460,"height":730,"url":"https:\/\/kinqsta.com\/nl\/wp-content\/uploads\/sites\/7\/2022\/09\/mongodb-operators.jpg","type":"image\/jpeg"}],"author":"Salman Ravoof","twitter_card":"summary_large_image","twitter_description":"Dit artikel beschrijft de belangrijkste MongoDB operators die je kunnen helpen de prestaties te verbeteren en laat je zien hoe je ze kunt gebruiken.","twitter_image":"https:\/\/kinqsta.com\/nl\/wp-content\/uploads\/sites\/7\/2022\/09\/mongodb-operators.jpg","twitter_creator":"@salmanravoof","twitter_site":"@Kinsta_NL","twitter_misc":{"Geschreven door":"Salman Ravoof","Geschatte leestijd":"36 minuten"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/kinqsta.com\/nl\/blog\/mongodb-operators\/#article","isPartOf":{"@id":"https:\/\/kinqsta.com\/nl\/blog\/mongodb-operators\/"},"author":{"name":"Salman Ravoof","@id":"https:\/\/kinqsta.com\/nl\/#\/schema\/person\/9cafd2eedd617e640eeea4cf3a5fd987"},"headline":"9 soorten Mongodb operators die je moet kennen","datePublished":"2022-09-19T08:37:22+00:00","dateModified":"2023-06-15T09:36:43+00:00","mainEntityOfPage":{"@id":"https:\/\/kinqsta.com\/nl\/blog\/mongodb-operators\/"},"wordCount":5469,"commentCount":0,"publisher":{"@id":"https:\/\/kinqsta.com\/nl\/#organization"},"image":{"@id":"https:\/\/kinqsta.com\/nl\/blog\/mongodb-operators\/#primaryimage"},"thumbnailUrl":"https:\/\/kinqsta.com\/nl\/wp-content\/uploads\/sites\/7\/2022\/09\/mongodb-operators.jpg","keywords":["datab","database","databases","develpoment","MongoDB"],"inLanguage":"nl-NL","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/kinqsta.com\/nl\/blog\/mongodb-operators\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/kinqsta.com\/nl\/blog\/mongodb-operators\/","url":"https:\/\/kinqsta.com\/nl\/blog\/mongodb-operators\/","name":"9 soorten Mongodb operators die je moet kennen - Kinsta\u00ae","isPartOf":{"@id":"https:\/\/kinqsta.com\/nl\/#website"},"primaryImageOfPage":{"@id":"https:\/\/kinqsta.com\/nl\/blog\/mongodb-operators\/#primaryimage"},"image":{"@id":"https:\/\/kinqsta.com\/nl\/blog\/mongodb-operators\/#primaryimage"},"thumbnailUrl":"https:\/\/kinqsta.com\/nl\/wp-content\/uploads\/sites\/7\/2022\/09\/mongodb-operators.jpg","datePublished":"2022-09-19T08:37:22+00:00","dateModified":"2023-06-15T09:36:43+00:00","description":"Dit artikel beschrijft de belangrijkste MongoDB operators die je kunnen helpen de prestaties te verbeteren en laat je zien hoe je ze kunt gebruiken.","breadcrumb":{"@id":"https:\/\/kinqsta.com\/nl\/blog\/mongodb-operators\/#breadcrumb"},"inLanguage":"nl-NL","potentialAction":[{"@type":"ReadAction","target":["https:\/\/kinqsta.com\/nl\/blog\/mongodb-operators\/"]}]},{"@type":"ImageObject","inLanguage":"nl-NL","@id":"https:\/\/kinqsta.com\/nl\/blog\/mongodb-operators\/#primaryimage","url":"https:\/\/kinqsta.com\/nl\/wp-content\/uploads\/sites\/7\/2022\/09\/mongodb-operators.jpg","contentUrl":"https:\/\/kinqsta.com\/nl\/wp-content\/uploads\/sites\/7\/2022\/09\/mongodb-operators.jpg","width":1460,"height":730},{"@type":"BreadcrumbList","@id":"https:\/\/kinqsta.com\/nl\/blog\/mongodb-operators\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/kinqsta.com\/nl\/"},{"@type":"ListItem","position":2,"name":"Webdevelopment tools","item":"https:\/\/kinqsta.com\/nl\/onderwerpen\/webdevelopment-tools\/"},{"@type":"ListItem","position":3,"name":"9 soorten Mongodb operators die je moet kennen"}]},{"@type":"WebSite","@id":"https:\/\/kinqsta.com\/nl\/#website","url":"https:\/\/kinqsta.com\/nl\/","name":"Kinsta\u00ae","description":"Snelle, veilige, premium hostingoplossingen","publisher":{"@id":"https:\/\/kinqsta.com\/nl\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/kinqsta.com\/nl\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"nl-NL"},{"@type":"Organization","@id":"https:\/\/kinqsta.com\/nl\/#organization","name":"Kinsta","url":"https:\/\/kinqsta.com\/nl\/","logo":{"@type":"ImageObject","inLanguage":"nl-NL","@id":"https:\/\/kinqsta.com\/nl\/#\/schema\/logo\/image\/","url":"https:\/\/kinqsta.com\/nl\/wp-content\/uploads\/sites\/7\/2023\/12\/kinsta-logo.jpeg","contentUrl":"https:\/\/kinqsta.com\/nl\/wp-content\/uploads\/sites\/7\/2023\/12\/kinsta-logo.jpeg","width":500,"height":500,"caption":"Kinsta"},"image":{"@id":"https:\/\/kinqsta.com\/nl\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/Kinsta-Nederland-476213452787823\/","https:\/\/x.com\/Kinsta_NL","https:\/\/www.instagram.com\/kinstahosting\/","https:\/\/www.linkedin.com\/company\/kinsta\/","https:\/\/www.pinterest.com\/kinstahosting\/","https:\/\/www.youtube.com\/c\/Kinsta"]},{"@type":"Person","@id":"https:\/\/kinqsta.com\/nl\/#\/schema\/person\/9cafd2eedd617e640eeea4cf3a5fd987","name":"Salman Ravoof","image":{"@type":"ImageObject","inLanguage":"nl-NL","@id":"https:\/\/kinqsta.com\/nl\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/0c5885f75cb78473fb7408e5e49ad190?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/0c5885f75cb78473fb7408e5e49ad190?s=96&d=mm&r=g","caption":"Salman Ravoof"},"description":"Salman Ravoof is a self-taught web developer, writer, creator, and a huge admirer of Free and Open Source Software (FOSS). Besides tech, he's excited by science, philosophy, photography, arts, cats, and food. Learn more about him on his website, and connect with Salman on Twitter.","sameAs":["https:\/\/salmanravoof.com","https:\/\/www.linkedin.com\/in\/salman-ravoof-5a749133\/","https:\/\/x.com\/salmanravoof"],"url":"https:\/\/kinqsta.com\/nl\/blog\/author\/salmanravoof\/"}]}},"acf":[],"_links":{"self":[{"href":"https:\/\/kinqsta.com\/nl\/wp-json\/wp\/v2\/posts\/45789","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/kinqsta.com\/nl\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/kinqsta.com\/nl\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/kinqsta.com\/nl\/wp-json\/wp\/v2\/users\/117"}],"replies":[{"embeddable":true,"href":"https:\/\/kinqsta.com\/nl\/wp-json\/wp\/v2\/comments?post=45789"}],"version-history":[{"count":12,"href":"https:\/\/kinqsta.com\/nl\/wp-json\/wp\/v2\/posts\/45789\/revisions"}],"predecessor-version":[{"id":51760,"href":"https:\/\/kinqsta.com\/nl\/wp-json\/wp\/v2\/posts\/45789\/revisions\/51760"}],"alternate":[{"embeddable":true,"hreflang":"en","title":"English","href":"https:\/\/kinqsta.com\/nl\/wp-json\/kinsta\/v1\/posts\/45789\/translations\/en"},{"embeddable":true,"hreflang":"it","title":"Italian","href":"https:\/\/kinqsta.com\/nl\/wp-json\/kinsta\/v1\/posts\/45789\/translations\/it"},{"embeddable":true,"hreflang":"pt","title":"Portuguese","href":"https:\/\/kinqsta.com\/nl\/wp-json\/kinsta\/v1\/posts\/45789\/translations\/pt"},{"embeddable":true,"hreflang":"fr","title":"French","href":"https:\/\/kinqsta.com\/nl\/wp-json\/kinsta\/v1\/posts\/45789\/translations\/fr"},{"embeddable":true,"hreflang":"de","title":"German","href":"https:\/\/kinqsta.com\/nl\/wp-json\/kinsta\/v1\/posts\/45789\/translations\/de"},{"embeddable":true,"hreflang":"ja","title":"Japanese","href":"https:\/\/kinqsta.com\/nl\/wp-json\/kinsta\/v1\/posts\/45789\/translations\/jp"},{"embeddable":true,"hreflang":"nl","title":"Dutch","href":"https:\/\/kinqsta.com\/nl\/wp-json\/kinsta\/v1\/posts\/45789\/translations\/nl"},{"embeddable":true,"hreflang":"es","title":"Spanish","href":"https:\/\/kinqsta.com\/nl\/wp-json\/kinsta\/v1\/posts\/45789\/translations\/es"},{"embeddable":true,"hreflang":"sv","title":"Swedish","href":"https:\/\/kinqsta.com\/nl\/wp-json\/kinsta\/v1\/posts\/45789\/translations\/se"},{"embeddable":true,"hreflang":"da","title":"Danish","href":"https:\/\/kinqsta.com\/nl\/wp-json\/kinsta\/v1\/posts\/45789\/translations\/dk"},{"href":"https:\/\/kinqsta.com\/nl\/wp-json\/kinsta\/v1\/posts\/45789\/tree"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/kinqsta.com\/nl\/wp-json\/wp\/v2\/media\/45790"}],"wp:attachment":[{"href":"https:\/\/kinqsta.com\/nl\/wp-json\/wp\/v2\/media?parent=45789"}],"wp:term":[{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/kinqsta.com\/nl\/wp-json\/wp\/v2\/tags?post=45789"},{"taxonomy":"topic","embeddable":true,"href":"https:\/\/kinqsta.com\/nl\/wp-json\/wp\/v2\/topic?post=45789"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}