Node.js Backend Development Bootcamp · Lezione

ODM Mongoose per la modellazione dei dati

Impari a definire schemi e modelli con Mongoose, strutturando in modo efficace i dati in MongoDB.

ODM Mongoose per la modellazione dei dati è una lezione Node.js Backend Development Bootcamp gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Node.js Backend Development Bootcamp, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Node.js Backend Development Bootcamp include 4 lezioni in totale.

Parti di questa lezione non sono ancora state tradotte e vengono mostrate in inglese.

Meet Mongoose Schemas

In the last lesson, we connected to MongoDB. Now, let's learn how to structure our data with Mongoose and Schemas.

Mongoose is an Object Data Modeling (ODM) library for MongoDB and Node.js. It provides a straightforward, schema-based solution to model your application data, making it easier to work with MongoDB.

Why Schemas Matter

MongoDB is a NoSQL database, meaning it's schema-less by default. While this offers great flexibility, it can lead to inconsistent data if not managed.

Mongoose schemas bring structure and consistency:

Define Data Shape: What fields a document should have.
Data Types: Ensure fields store correct types (String, Number, etc.).
Validation: Add rules like 'required' or 'minimum length'.

Defining Your First Schema

Let's define a basic schema for a Book. We'll specify properties like title and author, and their expected data types.

First, we need to import Mongoose, then create a new Schema object.

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.

Common Schema Types

Mongoose supports many data types that map to JavaScript types and MongoDB BSON types. Here are some of the most common ones:

String: For text like names, descriptions.
Number: For numerical values like age, price.
Boolean: For true/false values.
Date: For storing dates and times.
ObjectId: A special type for unique IDs, often used for references between documents.

Schema Options: Required & Default

Beyond just types, schemas allow you to add options to each field. These options control behavior and validation. Two common ones are required and default.

required: true: Means this field must have a value.
default: 'value': Provides a fallback value if none is specified during document creation.

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!');

Creating a Mongoose Model

A schema is like a blueprint. To actually interact with your MongoDB collection, you need to create a Model from that schema.

A Mongoose Model is a wrapper around the schema that provides an interface for the database: creating, querying, updating, and deleting records in a specific collection.

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.

Basic Field Validation

Mongoose schemas offer built-in validation to ensure data integrity before saving to the database. This helps keep your data clean and consistent.

You can define validators like minlength, maxlength, and enum (a list of allowed values) directly within your schema definition.

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!');

Embedding Documents

Sometimes, one document logically 'contains' another. Mongoose allows you to embed schemas directly within other schemas, creating nested documents.

This is useful for tightly coupled data that doesn't need its own separate collection, like an address within a user profile.

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.

Quick Check: Schema Fields

Imagine you're building a schema for a blog post. It needs a title (required string), content (string), and publishDate (date, defaults to now).

Which of the following Mongoose schema definitions correctly sets up these fields and their options?

Recap: Schemas & Models

Great job! You've learned the essentials of Mongoose schemas and models:

Schemas define the structure, data types, and validation rules for your MongoDB documents.
They provide consistency in a schema-less database.
You create Models from schemas to interact with specific collections in MongoDB.
We explored common types, options like required and default, and even embedding documents.

Next, we'll use these models to perform CRUD operations (Create, Read, Update, Delete)!

Domande Frequenti

La lezione «ODM Mongoose per la modellazione dei dati» è gratuita?

Sì — il testo completo di «ODM Mongoose per la modellazione dei dati» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Node.js Backend Development Bootcamp, passa a CoddyKit PRO. Il corso Node.js Backend Development Bootcamp include 4 lezioni in totale.

Cosa imparerò in «ODM Mongoose per la modellazione dei dati»?

Impari a definire schemi e modelli con Mongoose, strutturando in modo efficace i dati in MongoDB. Eserciti Node.js Backend Development Bootcamp con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Node.js Backend Development Bootcamp?

Non è richiesta alcuna esperienza precedente. Node.js Backend Development Bootcamp su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «ODM Mongoose per la modellazione dei dati»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Node.js Backend Development Bootcamp?

Sì. Ogni lezione Node.js Backend Development Bootcamp include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Collegare Node.js a MongoDB
ODM Mongoose per la modellazione dei dati
Operazioni CRUD con Mongoose
Query e filtri dei dati con Mongoose

← Torna a Node.js Backend Development Bootcamp