Share
Mongoose is een JavaScript-framework dat veel wordt gebruikt in een Node.js-applicatie met een MongoDB-database. In dit artikel ga ik je voorstellen aan Mongoose en MongoDB, en nog belangrijker, waar deze technologieën in je toepassing passen.
Laten we beginnen met MongoDB. MongoDB is een database die uw gegevens als documenten opslaat. Meestal lijken deze documenten op een JSON-achtige structuur:
firstName: "Jamie", lastName: "Munro"
Een document wordt vervolgens in een verzameling geplaatst. Als voorbeeld definieert het bovenstaande documentvoorbeeld a gebruiker voorwerp. Deze gebruiker object zou dan typisch deel uitmaken van een verzameling genaamd gebruikers.
Een van de belangrijkste factoren bij MongoDB is de flexibiliteit als het gaat om structuur. Hoewel in het eerste voorbeeld, de gebruiker object bevatte een Voornaam en achternaam eigenschap, deze eigenschappen zijn niet vereist in elke gebruiker document dat deel uitmaakt van de gebruikers verzameling. Dit is wat MongoDB heel anders maakt dan een SQL-database zoals MySQL of Microsoft SQL Server die een sterk gedefinieerd databaseschema vereist voor elk object dat het opslaat.
De mogelijkheid om dynamische objecten te maken die als documenten in de database worden opgeslagen, is waar Mongoose in het spel komt.
Mongoose is een Object Document Mapper (ODM). Dit betekent dat u met Mongoose objecten kunt definiëren met een sterk getypt schema dat is toegewezen aan een MongoDB-document.
Mongoose biedt een ongelooflijke hoeveelheid functionaliteit rond het maken en werken met schema's. Mongoose bevat momenteel acht SchemaTypes die een eigenschap opslaan als wanneer deze wordt aangehouden tot MongoDB. Zij zijn:
Met elk gegevenstype kunt u opgeven:
Naast deze algemene opties kunt u met bepaalde gegevenstypen verder aanpassen hoe de gegevens worden opgeslagen en uit de database worden opgehaald. Bijvoorbeeld a Draad gegevenstype kunt u ook de volgende aanvullende opties opgeven:
De Aantal en Datum eigenschappen ondersteunen beide een minimum- en maximumwaarde opgeven die is toegestaan voor dat veld.
De meeste van de acht toegestane gegevenstypen zouden u heel bekend moeten zijn. Er zijn echter verschillende uitzonderingen die mogelijk voor u van toepassing zijn, zoals Buffer, Gemengd, ObjectId, en reeks.
De Buffer gegevenstype kunt u binaire gegevens opslaan. Een bekend voorbeeld van binaire gegevens is een afbeelding of een gecodeerd bestand, zoals een PDF-document.
De Gemengd gegevenstype verandert de eigenschap in een "alles gaat" veld. Dit veld lijkt op hoeveel ontwikkelaars MongoDB kunnen gebruiken omdat er geen gedefinieerde structuur is. Wees op uw hoede voor het gebruik van dit gegevenstype, omdat het veel van de geweldige functies verliest die Mongoose biedt, zoals gegevensvalidatie en het detecteren van wijzigingen in de entiteit om automatisch te weten dat het eigendom bij het opslaan moet worden bijgewerkt.
De ObjectId gegevenstype geeft gewoonlijk een koppeling aan naar een ander document in uw database. Als u bijvoorbeeld een verzameling boeken en auteurs had, bevat het boekdocument mogelijk een ObjectId eigenschap die verwijst naar de specifieke auteur van het document.
De reeks gegevenstype kunt u JavaScript-achtige arrays opslaan. Met een gegevenstype Array kunt u algemene JavaScript-arraybewerkingen op deze uitvoeren, zoals pushen, poppen, verschuiven, segmenteren, enzovoort.
Voordat ik verderging en een code genereerde, wilde ik alleen maar herhalen wat we zojuist hebben geleerd. MongoDB is een database waarmee u documenten met een dynamische structuur kunt opslaan. Deze documenten worden in een verzameling opgeslagen.
Mongoose is een JavaScript-bibliotheek waarmee u schema's met sterk getypeerde gegevens kunt definiëren. Zodra een schema is gedefinieerd, kunt u met Mongoose een model maken op basis van een specifiek schema. Een Mongoso-model wordt vervolgens toegewezen aan een MongoDB-document via de schemadefinitie van het model.
Nadat u uw schema's en modellen hebt gedefinieerd, bevat Mongoose veel verschillende functies waarmee u uw gegevens kunt valideren, opslaan, verwijderen en doorzoeken met behulp van de gebruikelijke MongoDB-functies. Ik zal hier meer over praten met de concrete codevoorbeelden die moeten volgen.
Voordat we onze Mongoose-schema's en -modellen kunnen maken, moet MongoDB worden geïnstalleerd en geconfigureerd. Ik zou willen voorstellen om de MongoDB-downloadpagina te bezoeken. Er zijn verschillende opties beschikbaar om te installeren. Ik heb gelinkt aan de Community Server. Hiermee kunt u een versie installeren die specifiek is voor uw besturingssysteem. MongoDB biedt ook een Enterprise Server en een cloud-ondersteuningsinstallatie. Omdat hele boeken kunnen worden geschreven over het installeren, afstemmen en monitoren van MongoDB, blijf ik bij de Community Server.
Nadat u MongoDB voor uw besturingssysteem naar keuze hebt gedownload en geïnstalleerd, moet u de database starten. In plaats van het wiel opnieuw uit te vinden, raad ik aan om MongoDB's documentatie over het installeren van de MongoDB Community Edition te bezoeken.
Ik zal hier wachten terwijl je MongoDB configureert. Wanneer u klaar bent, kunnen we doorgaan met het instellen van Mongoose om verbinding te maken met uw nieuw geïnstalleerde MongoDB-database.
Mongoose is een JavaScript-framework en ik ga het gebruiken in een Node.js-applicatie. Als u Node.js al hebt geïnstalleerd, kunt u doorgaan naar de volgende stap. Als u Node.js niet hebt geïnstalleerd, raad ik u aan om eerst naar de downloadpagina van Node.js te gaan en het installatieprogramma voor uw besturingssysteem te selecteren.
Nu Node.js is opgezet en klaar is voor gebruik, ga ik een nieuwe applicatie maken en vervolgens het Mongoose NPM-pakket installeren.
Met een opdrachtprompt die is ingesteld op de plaats waar u uw toepassing wilt installeren, kunt u de volgende opdrachten uitvoeren:
mkdir mongoose_basics cd mongoose_basics npm init
Voor de initialisatie van mijn applicatie liet ik alles als hun standaardwaarden. Nu ga ik het mangoesten pakket als volgt installeren:
npm mongoose installeren - opslaan
Met alle vereiste voorwaarden geconfigureerd, laten we verbinding maken met een MongoDB-database. Ik heb de volgende code in een index.js-bestand geplaatst, omdat ik dat als beginpunt voor mijn toepassing heb gekozen:
Accentsconagua
var mongoose = vereisen ('mongoose'); mongoose.connect ( 'MongoDB: // localhost / mongoose_basics');De eerste regel code bevat de mangoest bibliotheek. Vervolgens open ik een verbinding met een database die ik heb gebeld mongoose_basics de ... gebruiken aansluiten functie.
De aansluiten functie accepteert twee andere optionele parameters. De tweede parameter is een object met opties waarmee u, zoals vereist, zaken als de gebruikersnaam en het wachtwoord kunt definiëren. De derde parameter, die ook de tweede parameter kan zijn als u geen opties heeft, is de callback-functie na een poging verbinding te maken. De callback-functie kan op twee manieren worden gebruikt:
mongoose.connect (uri, opties, functie (fout) // Controleer de fout bij de eerste verbinding Er is geen 2e param voor de terugbelopdracht.); // Of het gebruik van beloftes mongoose.connect (uri, opties) .then (() => / ** klaar voor gebruik. De belofte 'mongoose.connect ()' lost naar undefined. * /, Err => / ** behandel initiële verbindingsfout * /);
Om een mogelijke introductie van JavaScript Promises te voorkomen, zal ik de eerste manier gebruiken. Hieronder staat een bijgewerkt index.js-bestand:
var mongoose = vereisen ('mongoose'); mongoose.connect ('mongodb: // localhost / mongoose_basics', function (err) if (err) gooi err; console.log ('Successfully connected'););Als er een fout optreedt bij het verbinden met de database, wordt de uitzondering gegenereerd en wordt alle verdere verwerking gestopt. Als er geen fout optreedt, heb ik een succesbericht bij de console geregistreerd.
Mongoose is nu ingesteld en verbonden met een database met de naam mongoose_basics. Mijn MongoDB-verbinding gebruikt geen gebruikersnaam, wachtwoord of aangepaste poort. Als je tijdens het verbinden deze opties of een andere optie moet instellen, raad ik aan de Mongoose-documentatie over verbinden te bekijken. De documentatie biedt gedetailleerde uitleg over de vele beschikbare opties, evenals hoe u meerdere verbindingen kunt maken, verbindingspooling, replica's, enz.
Laten we met een succesvolle verbinding verder gaan om een Mongoose-schema te definiëren.
Tijdens de introductie liet ik een gebruiker object dat twee eigenschappen bevat: Voornaam en achternaam. In het volgende voorbeeld heb ik dat document in een Mongoose-schema vertaald:
var userSchema = mongoose.Schema (firstName: String, lastName: String);
Dit is een zeer eenvoudig schema dat slechts twee eigenschappen bevat waaraan geen attributen zijn gekoppeld. Laten we dit voorbeeld uitbreiden door de eigenschappen van de voor- en achternaam om te zetten in onderliggende objecten van a naam eigendom. De naam eigendom omvat zowel de voor- als achternaam. Ik zal ook een toevoegen aangemaakt eigenschap die van het type is Datum.
var userSchema = mongoose.Schema (name: firstName: String, lastName: String, created: Date);
Zoals je ziet, stelt Mongoose me in staat om zeer flexibele schema's te maken met veel verschillende mogelijke combinaties van hoe ik mijn gegevens kan ordenen.
In dit volgende voorbeeld ga ik twee nieuwe schema's maken die laten zien hoe je een relatie met een ander schema kunt maken: schrijver en boek. De boek schema zal een verwijzing naar de bevatten schrijver schema.
var authorSchema = mongoose.Schema (_id: mongoose.Schema.Types.ObjectId, name: firstName: String, lastName: String, biography: String, twitter: String, facebook: String, linkedin: String, profilePicture: Buffer, gemaakt: type: Datum, standaard: Date.now);
Hierboven is de schrijver schema dat zich uitstrekt over de concepten van de gebruiker schema dat ik in het vorige voorbeeld heb gemaakt. Om de auteur en het boek samen te linken, is de eerste eigenschap van de schrijver schema is een _ID kaart eigendom dat een is ObjectId schema type. _ID kaart is de algemene syntaxis voor het maken van een primaire sleutel in Mongoose en MongoDB. Dan, zoals de gebruiker schema, ik heb een gedefinieerd naam property met de voor- en achternaam van de auteur.
Uitbreiden op de gebruiker schema, de schrijver bevat verschillende andere Draad schemasoorten. Ik heb ook een toegevoegd Buffer schemasoort dat de profielfoto van de auteur kan bevatten. De laatste eigenschap bevat de gemaakte datum van de auteur; het kan echter zijn dat het iets anders is gemaakt omdat het een standaardwaarde van "nu" heeft gedefinieerd. Wanneer een auteur persistent is in de database, wordt deze eigenschap ingesteld op de huidige datum / tijd.
Om de schemavoorbeelden te voltooien, maken we een boek schema dat een verwijzing naar de auteur bevat met behulp van de ObjectId schema type:
var bookSchema = mongoose.Schema (_id: mongo.Schema.Types.ObjectId, title: String, summary: String, isbn: String, miniatuur: Buffer, auteur: type: mongoose.Schema.Types.ObjectId, ref: ' Author ', ratings: [summary: String, detail: String, numberOfStars: Number, created: type: Date, default: Date.now], created: type: Date, default: Date.now );
De boek schema bevat verschillende eigenschappen van het type Draad. Zoals hierboven vermeld, bevat het een verwijzing naar de schrijver schema. Om de krachtige schemadefinities verder te demonstreren, de boek schema bevat ook een reeks van ratings. Elke rating bestaat uit een samenvatting, detail-, numberOfStars, en aangemaakt date eigenschap.
Mongoose biedt u de flexibiliteit om schema's te maken met verwijzingen naar andere schema's of, zoals in het bovenstaande voorbeeld met de ratings property, hiermee kunt u een maken reeks van kindeigenschappen die kunnen zijn opgenomen in een gerelateerd schema (zoals boek aan auteur) of inline zoals in het bovenstaande voorbeeld (met boek naar beoordelingen reeks).
Sinds de schrijver en boek schema's tonen de flexibiliteit van Mongoose's schema, ik ga door met het gebruik van die schema's en leid een schema af Schrijver en Boek model van hen.
var Auteur = mongoose.model ('Auteur', auteur Schema); var Book = mongoose.model ('Book', bookSchema);Een Mongoose-model, wanneer het is opgeslagen, maakt een document in MongoDB met de eigenschappen zoals gedefinieerd door het schema waarvan het is afgeleid.
Om het maken en opslaan van een object te demonstreren, ga ik in dit volgende voorbeeld verschillende objecten maken: Schrijver Model en meerdere Boek Models. Als deze objecten eenmaal zijn gemaakt, blijven ze bestaan in MongoDB met behulp van de opslaan methode van het model.
var jamieAuthor = new Auteur _id: new mongoose.Types.ObjectId (), name: firstName: 'Jamie', lastName: 'Munro', biografie: 'Jamie is de auteur van ASP.NET MVC 5 met Bootstrap en Knockout .js. ', twitter:' https://twitter.com/endyourif ', facebook:' https://www.facebook.com/End-Your-If-194251957252562/ '; jamieAuthor.save (function (err) if (err) gooi err; console.log ('Auteur succesvol opgeslagen.'); var mvcBook = new Book _id: new mongoose.Types.ObjectId (), title: 'ASP. NET MVC 5 met Bootstrap en Knockout.js ', auteur: jamieAuthor._id, ratings: [summary:' Great read ']; mvcBook.save (function (err) if (err) gooi err; console.log ('Boek succesvol opgeslagen.');); Var knockoutBook = new Book _id: new mongoose.Types.ObjectId (), title: 'Knockout.js: Dynamische client-side webapplicaties bouwen', auteur: jamieAuthor._id ; knockoutBook.save (function (err) if (err) gooi err; console.log ('Boek succesvol opgeslagen.';;););In het bovenstaande voorbeeld heb ik schaamteloos een verwijzing naar mijn twee meest recente boeken ingeplugd. Het voorbeeld begint met het maken en opslaan van een jamieObject dat is gemaakt van eenSchrijver Model. Binnen in de opslaan functie van de jamieObject, als er een fout optreedt, zal de applicatie een uitzondering uitvoeren. Wanneer het opslaan succesvol is, binnen de opslaan functie, worden de twee boekobjecten gemaakt en opgeslagen. Vergelijkbaar met de jamieObject, als er een fout optreedt tijdens het opslaan, wordt een fout uitgevoerd; anders wordt een succesbericht uitgevoerd in de console.
Om de verwijzing naar de auteur te maken, verwijzen de boekobjecten beide naar de schrijver schema's _ID kaart primaire sleutel in de schrijver eigendom van de boek schema.
Het komt vrij vaak voor dat de gegevens uiteindelijk een model vormen dat moet worden ingevuld door een formulier op een webpagina. Daarom is het een goed idee om deze gegevens te valideren voordat het model op MongoDB wordt opgeslagen.
In dit volgende voorbeeld heb ik het vorige auteursschema bijgewerkt om validatie toe te voegen aan de volgende eigenschappen: Voornaam, tjilpen, facebook, en linkedin.
var authorSchema = mongoose.Schema (_id: mongo.Schema.Types.ObjectId, name: firstName: type: String, required: true, lastName: String, biography: String, twitter: type: String, validate : validator: functie (tekst) return text.indexOf ('https://twitter.com/') === 0;, bericht: 'Twitter-handle moet beginnen met https://twitter.com/' , facebook: type: String, valideren: validator: functie (tekst) return text.indexOf ('https://www.facebook.com/') === 0;, bericht: 'Facebook moet starten met https://www.facebook.com/ ', linkedin: type: String, valideren: validator: functie (tekst) return text.indexOf (' https://www.linkedin.com/ ') === 0;, bericht: 'LinkedIn moet beginnen met https://www.linkedin.com/', profilePicture: Buffer, aangemaakt: type: Date, default: Date.now);De Voornaam eigenschap is toegeschreven aan de verplicht eigendom. Nu, wanneer ik de opslaan functie, geeft Mongoose een foutmelding met een bericht dat aangeeft dat Voornaam eigendom is verplicht. Ik heb ervoor gekozen om de achternaam eigendom vereist in het geval dat Cher of Madonna auteurs in mijn database zouden zijn.
De tjilpen, facebook, en linkedin eigenschappen hebben allemaal zeer vergelijkbare aangepaste validators die op hen zijn toegepast. Ze zorgen er elk voor dat de waarden beginnen met de respectieve domeinnaam van de sociale netwerken. Deze velden zijn niet vereist, dus de validator wordt alleen toegepast wanneer gegevens voor die eigenschap worden verstrekt.
Een inleiding tot Mongoose zou niet compleet zijn zonder een voorbeeld van het zoeken naar een record en het bijwerken van een of meer eigenschappen van dat object.
Mongoose biedt verschillende functies om gegevens voor een specifiek model te vinden. De functies zijn vind, vind een, en findById.
De vind en vind een functies accepteren beide een object als invoer voor complexe zoekopdrachten, terwijl findById accepteert slechts een enkele waarde met een callback-functie (een voorbeeld volgt binnenkort). In dit volgende voorbeeld ga ik demonstreren hoe alle boeken met de tekenreeks "mvc" in hun titel kunnen worden gevonden.
Book.find (title: / mvc / i). Exec (functie (err, books) if (err) gooi err; console.log (books););
Binnen in de vind functie, ik ben op zoek naar de hoofdletterongevoelige tekenreeks "mvc" op de titel eigendom. Dit wordt bereikt met dezelfde syntaxis voor het zoeken van een tekenreeks met JavaScript.
De zoekfunctie-aanroep wordt ook geketend aan andere query-methoden, zoals waar, en, of, begrenzing, soort, ieder, enz.
Laten we verder gaan met het vorige voorbeeld om onze resultaten te beperken tot de eerste vijf boeken en te sorteren op de gemaakte datum die afloopt. Dit zal terugkeren naar de vijf meest recente boeken met "mvc" in de titel.
Book.find (title: / mvc / i). Sort ('- created') .limit (5) .exec (functie (err, books) if (err) throw err; console.log (books); );Na het toepassen van de vind functie, de volgorde van de andere functies is niet belangrijk omdat alle gekoppelde functies samen worden gecompileerd tot een enkele query en niet geëxecuteerd tot de exec functie wordt aangeroepen.
Zoals ik eerder al zei, de findById is een beetje anders uitgevoerd. Het wordt onmiddellijk uitgevoerd en accepteert een callback-functie, in plaats van een reeks functies toe te staan. In dit volgende voorbeeld, vraag ik een specifieke auteur door hun _ID kaart.
Author.findById ('59b31406beefa1082819e72f', functie (err, auteur) if (err) gooi err; console.log (auteur););De _ID kaart in jouw geval kan het iets anders zijn. Ik heb dit gekopieerd _ID kaart van een vorige console.log bij het vinden van een lijst met boeken met "mvc" in hun titel.
Nadat een object is geretourneerd, kunt u een van de eigenschappen ervan wijzigen om het bij te werken. Zodra u de nodige wijzigingen hebt aangebracht, belt u de opslaan methode, net zoals toen je het object aan het maken was. In dit volgende voorbeeld zal ik het uitbreiden findbyId voorbeeld en update de linkedin eigendom van de auteur.
Author.findById ('59b31406beefa1082819e72f', functie (err, auteur) if (err) gooi err; author.linkedin = 'https://www.linkedin.com/in/jamie-munro-8064ba1a/' author.save (functie (err) if (err) gooi err; console.log ('Auteur is succesvol bijgewerkt');););Nadat de auteur is opgehaald, de linkedin eigenschap is ingesteld en de opslaan functie wordt aangeroepen. Mongoose kan detecteren dat de linkedin eigenschap is gewijzigd en het stuurt een updatebericht naar MongoDB over alleen de eigenschappen die zijn gewijzigd. Als er een fout is opgetreden tijdens het opslaan, wordt een uitzondering gegenereerd en stopt de toepassing. Als dit lukt, wordt er een succesbericht bij de console geregistreerd.
Mongoose biedt ook twee extra functies waarmee u een object kunt vinden en het in één stap kunt opslaan met de toepasselijke functies: findByIdAndUpdate en findOneAndUpdate. Laten we het vorige voorbeeld bijwerken om het te gebruiken findByIdAndUpdate.
Author.findByIdAndUpdate ('59b31406beefa1082819e72f', linkedin: 'https://www.linkedin.com/in/jamie-munro-8064ba1a/', function (err, auteur) if (err) gooi err; console.log (schrijver); );In het vorige voorbeeld worden de eigenschappen die moeten worden bijgewerkt, geleverd als een object voor de tweede parameter van de findByIdAndUpdate functie. De callback-functie is nu de derde parameter. Wanneer de update succesvol is, is de schrijver geretourneerd object bevat de bijgewerkte informatie. Dit wordt vastgelegd op de console om de eigenschappen van de bijgewerkte auteur te bekijken.
In dit artikel heb ik kleine codefragmenten verstrekt waarmee een heel specifieke actie kan worden geïdentificeerd, zoals het maken van een schema, het maken van een model, enzovoort. Laten we het allemaal samenvatten in een volledig voorbeeld.
Ten eerste heb ik twee extra bestanden gemaakt: author.js en book.js. Deze bestanden bevatten hun respectieve schemadefinities en het maken van het model. De laatste regel code maakt het model beschikbaar voor gebruik in de index.js het dossier.
Laten we beginnen met het bestand author.js:
var mongoose = vereisen ('mongoose'); var authorSchema = mongoose.Schema (_id: mongo.Schema.Types.ObjectId, name: firstName: type: String, required: true, lastName: String, biography: String, twitter: type: String, validate : validator: functie (tekst) return text.indexOf ('https://twitter.com/') === 0;, bericht: 'Twitter-handle moet beginnen met https://twitter.com/' , facebook: type: String, valideren: validator: functie (tekst) return text.indexOf ('https://www.facebook.com/') === 0;, bericht: 'Facebook moet starten met https://www.facebook.com/ ', linkedin: type: String, valideren: validator: functie (tekst) return text.indexOf (' https://www.linkedin.com/ ') === 0;, bericht: 'LinkedIn moet beginnen met https://www.linkedin.com/', profilePicture: Buffer, aangemaakt: type: Date, default: Date.now); var Auteur = mongoose.model ('Auteur', auteur Schema); module.exports = Auteur;Vervolgens komt het book.js het dossier:
var mongoose = vereisen ('mongoose'); var bookSchema = mongoose.Schema (_id: mongo.Schema.Types.ObjectId, title: String, summary: String, isbn: String, miniatuur: Buffer, auteur: type: mongoose.Schema.Types.ObjectId, ref: ' Author ', ratings: [summary: String, detail: String, numberOfStars: Number, created: type: Date, default: Date.now], created: type: Date, default: Date.now ); var Book = mongoose.model ('Book', bookSchema); module.exports = Boek;En tot slot, de bijgewerkte index.js het dossier:
var mongoose = vereisen ('mongoose'); var Auteur = require ('./ author'); var Book = require ('./ book'); mongoose.connect ('mongodb: // localhost / mongoose_basics', function (err) if (err) gooi err; console.log ('Successfully connected'); var jamieAuthor = new Auteur (_id: new mongoose.Types. ObjectId (), naam: firstName: 'Jamie', lastName: 'Munro', biografie: 'Jamie is de auteur van ASP.NET MVC 5 met Bootstrap en Knockout.js.', Twitter: 'https: // twitter .com / endyourif ', facebook:' https://www.facebook.com/End-Your-If-194251957252562/ '); jamieAuthor.save (function (err) if (err) gooi err; console.log ('Auteur succesvol opgeslagen.'); Var mvcBook = new Book (_id: new mongoose.Types.ObjectId (), title: 'ASP.NET MVC 5 with Bootstrap and Knockout.js', auteur: jamieAuthor._id, beoordelingen : [summary: 'Great read']); mvcBook.save (function (err) if (err) gooi err; console.log ('Boek succesvol opgeslagen.');); var knockoutBook = new Book (_id: new mongoose.Types.ObjectId (), title: 'Knockout.js: Dynamische client-side webapplicaties bouwen', auteur: jamieAuthor._id); knockoutBook.save (funct ion (err) if (err) gooi fout; console.log ('Boek succesvol opgeslagen.'); ); ); );In het bovenstaande voorbeeld zijn alle acties van Mongoose opgenomen in de aansluiten functie. De schrijver en boek bestanden worden meegeleverd met de vereisen functie na het opnemen van de mangoest bibliotheek.
Als MongoDB wordt uitgevoerd, kunt u nu de volledige Node.js-toepassing uitvoeren met de volgende opdracht:
node index.js
Nadat ik wat gegevens in mijn database heb opgeslagen, heb ik de index.js bestand met de zoekfuncties als volgt:
var mongoose = vereisen ('mongoose'); var Auteur = require ('./ author'); var Book = require ('./ book'); mongoose.connect ('mongodb: // localhost / mongoose_basics', function (err) if (err) gooi err; console.log ('Successfully connected'); Book.find (title: / mvc / i). sort ('- created') .limit (5) .exec (functie (err, books) if (err) gooi err; console.log (books);); Author.findById ('59b31406beefa1082819e72f', functie (err , auteur) if (er) fout gooi; author.linkedin = 'https://www.linkedin.com/in/jamie-munro-8064ba1a/' author.save (function (err) if (err) gooi err; console.log ('Auteur is succesvol bijgewerkt'););); Auteur.findByIdAndUpdate ('59b31406beefa1082819e72f', linkedin: 'https://www.linkedin.com/in/jamie-munro-8064ba1a/' , functie (err, auteur) if (err) gooi err; console.log (auteur);););Nogmaals, u kunt de applicatie uitvoeren met de opdracht: node index.js.
Na het lezen van dit artikel zou je in staat moeten zijn om extreem flexibele Mongoose-schema's en -modellen te maken, eenvoudige of complexe validatie toe te passen, documenten te maken en bij te werken en uiteindelijk te zoeken naar de documenten die werden aangemaakt.
Hopelijk voel je je nu comfortabel met het gebruik van Mongoose. Als u meer wilt weten, raad ik u aan om de Mongoose-handleidingen te herzien die dieper ingaan op geavanceerdere onderwerpen zoals populatie, middleware, beloften, enz..
Happy hunting (arme Mongoose animal reference)!
