Bootcamp i backendutveckling med Node.js · Lektion

Mongoose ODM för datamodellering

Lär er definiera scheman och modeller med Mongoose och strukturera era data effektivt i MongoDB.

Lektion 2 av 410 steg

Mongoose ODM för datamodellering är en gratis lektion i Bootcamp i backendutveckling med Node.js på CoddyKit. Detta är lektion 2 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Bootcamp i backendutveckling med Node.js, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Bootcamp i backendutveckling med Node.js innehåller totalt 4 lektioner.

Lär känna Mongoose-scheman

I den förra lektionen anslöt vi till MongoDB. Nu ska Ni lära Er hur Ni strukturerar Era data med Mongoose och Schemas.

Mongoose är ett bibliotek för Object Data Modeling (ODM) för MongoDB och Node.js. Det erbjuder en enkel, schemabaserad lösning för att modellera applikationens data, vilket gör det enklare att arbeta med MongoDB.

Varför scheman är viktiga

MongoDB är en NoSQL-databas, vilket innebär att den saknar schema som standard. Även om detta ger stor flexibilitet kan det leda till inkonsekventa data om det inte hanteras på rätt sätt.

Mongoose-scheman ger struktur och konsekvens:

Definiera datastrukturen: Vilka fält ett dokument ska innehålla.
Datatyper: Säkerställ att fälten lagrar rätt datatyper (String, Number och så vidare).
Validering: Lägg till regler som ”required” eller ”minimum length”.

Definiera Ert första schema

Låt oss definiera ett grundläggande schema för en Book. Vi anger egenskaper som title och author samt deras förväntade datatyper.

Först behöver vi importera Mongoose och sedan skapa ett nytt Schema-objekt.

const mongoose = require('mongoose');

// Define the Book Schema
const bookSchema = new mongoose.Schema({
  title: String,
  author: String,
  pages: Number,
  isPublished: Boolean
});

console.log('Book Schema defined!');
// In a real app, this schema would be used to create a model.

Vanliga schematyper

Mongoose har stöd för många datatyper som motsvarar JavaScript-typer och MongoDB:s BSON-typer. Här är några av de vanligaste:

String: För text som namn och beskrivningar.
Number: För numeriska värden som ålder och pris.
Boolean: För värdena true/false.
Date: För lagring av datum och tider.
ObjectId: En särskild typ för unika ID:n, som ofta används för referenser mellan dokument.

Schemaalternativ: Required och Default

Utöver datatyper kan scheman tillåta att Ni lägger till alternativ för varje fält. Dessa alternativ styr beteende och validering. Två vanliga alternativ är required och default.

required: true: Innebär att fältet måste ha ett värde.
default: 'value': Anger ett reservvärde om inget värde anges när dokumentet skapas.

const mongoose = require('mongoose');

const productSchema = new mongoose.Schema({
  name: {
    type: String,
    required: true // Name is mandatory
  },
  price: {
    type: Number,
    required: true,
    default: 0 // Default price is 0 if not set
  },
  createdAt: {
    type: Date,
    default: Date.now // Automatically set current date
  }
});

console.log('Product Schema with options defined!');

Skapa en Mongoose-modell

Ett schema fungerar som en ritning. För att faktiskt kunna interagera med Er MongoDB-samling behöver Ni skapa en Model från schemat.

En Mongoose Model är ett omslag runt schemat som tillhandahåller ett gränssnitt mot databasen: skapa, söka efter, uppdatera och ta bort poster i en specifik samling.

const mongoose = require('mongoose');

// Define a simple User Schema
const userSchema = new mongoose.Schema({
  name: String,
  email: String
});

// Create a Model from the schema
// 'User' is the singular name. Mongoose will use 'users' as collection name.
const User = mongoose.model('User', userSchema);

console.log('User Model created from schema!');
// Now you can use the User model to interact with the 'users' collection.

Grundläggande fältvalidering

Mongoose-scheman erbjuder inbyggd validering för att säkerställa dataintegriteten innan data sparas i databasen. Det hjälper Er att hålla Era data rena och konsekventa.

Ni kan definiera validerare som minlength, maxlength och enum (en lista över tillåtna värden) direkt i schemadefinitionen.

const mongoose = require('mongoose');

const taskSchema = new mongoose.Schema({
  description: {
    type: String,
    required: true,
    minlength: 5, // Must be at least 5 characters
    maxlength: 100 // Max 100 characters
  },
  status: {
    type: String,
    enum: ['pending', 'completed', 'cancelled'], // Only these values allowed
    default: 'pending'
  }
});

console.log('Task Schema with validation rules defined!');

Bädda in dokument

Ibland innehåller ett dokument logiskt sett ett annat. Med Mongoose kan Ni bädda in scheman direkt i andra scheman och därmed skapa nästlade dokument.

Detta är användbart för tätt kopplade data som inte behöver en egen separat samling, till exempel en adress i en användarprofil.

const mongoose = require('mongoose');

// Define an Address Schema
const addressSchema = new mongoose.Schema({
  street: String,
  city: String,
  zip: String
});

// Embed Address Schema within a Person Schema
const personSchema = new mongoose.Schema({
  name: String,
  // The 'address' field will be a nested document using addressSchema
  address: addressSchema 
});

console.log('Person Schema with embedded Address Schema defined!');
// A 'Person' document will now contain an 'address' object.

Snabb kontroll: schemafält

Föreställ Er att Ni bygger ett schema för ett blogginlägg. Det behöver title (obligatorisk sträng), content (sträng) och publishDate (datum, med standardvärdet nu).

Vilken av följande Mongoose-schemadefinitioner konfigurerar dessa fält och alternativ korrekt?

Besvara frågan i den interaktiva lektionen

Sammanfattning: scheman och modeller

Bra jobbat! Ni har lärt Er grunderna i Mongoose-scheman och modeller:

Scheman definierar struktur, datatyper och valideringsregler för Era MongoDB-dokument.
De ger konsekvens i en databas som saknar schema.
Ni skapar Models från scheman för att interagera med specifika samlingar i MongoDB.
Vi gick igenom vanliga typer, alternativ som required och default samt hur dokument kan bäddas in.

Härnäst ska vi använda dessa modeller för att utföra CRUD-operationer (Create, Read, Update, Delete)!

Gratis att börja

Lär dig JavaScript med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 22
Lektioner: 92

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Mongoose ODM för datamodellering” gratis?

Ja – hela texten till ”Mongoose ODM för datamodellering” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Bootcamp i backendutveckling med Node.js, kan Ni uppgradera till CoddyKit PRO. Kursen i Bootcamp i backendutveckling med Node.js innehåller totalt 4 lektioner.

Vad lär jag mig i ”Mongoose ODM för datamodellering”?

Lär er definiera scheman och modeller med Mongoose och strukturera era data effektivt i MongoDB. Ni övar på Bootcamp i backendutveckling med Node.js med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Bootcamp i backendutveckling med Node.js?

Du behöver inga förkunskaper. Utbildningen i Bootcamp i backendutveckling med Node.js på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Mongoose ODM för datamodellering”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Bootcamp i backendutveckling med Node.js-lektionen?

Ja. Varje Bootcamp i backendutveckling med Node.js-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Bootcamp i backendutveckling med Node.js