Einschränkungen für Typ, Pflichtfelder und Enum
Definieren Sie innerhalb eines JSON-Schema-Validators Typbeschränkungen, Pflichtfelder und eine Aufzählung zulässiger Werte.
Einschränkungen für Typ, Pflichtfelder und Enum ist eine kostenlose MongoDB Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des MongoDB Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der MongoDB Academy-Kurs umfasst insgesamt 4 Lektionen.
Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.
The Three Core Constraint Types
MongoDB JSON Schema validators support three fundamental constraint categories that cover the majority of real-world validation needs: type constraints that enforce the BSON data type of a field, required constraints that mandate the presence of certain fields, and enum constraints that restrict a field's value to a predefined whitelist. Together they form the backbone of any production schema validator.
BSON Types vs JSON Schema Types
JSON Schema uses standard JSON types like string, number, and object. MongoDB extends this with BSON types declared via the bsonType keyword—values like objectId, date, int, long, double, and decimal. Always use bsonType in MongoDB validators (not type) when you need precision about numeric subtypes or MongoDB-specific types like objectId and date.
// BSON type names to use in validators
// 'string', 'bool', 'int', 'long', 'double', 'decimal',
// 'objectId', 'date', 'array', 'object', 'null', 'binData'
db.createCollection('products', {
validator: {
$jsonSchema: {
bsonType: 'object',
properties: {
_id: { bsonType: 'objectId' },
price: { bsonType: 'decimal' },
stock: { bsonType: 'int' },
isActive: { bsonType: 'bool' },
createdAt: { bsonType: 'date' }
}
}
}
});Declaring Required Fields
The required keyword takes an array of field names that must be present in every document inserted or updated in the collection. If any required field is missing, the write is rejected. Required fields are declared at the schema level, not inside individual property definitions.
db.createCollection('employees', {
validator: {
$jsonSchema: {
bsonType: 'object',
required: ['firstName', 'lastName', 'email', 'hiredAt'],
properties: {
firstName: { bsonType: 'string' },
lastName: { bsonType: 'string' },
email: { bsonType: 'string' },
hiredAt: { bsonType: 'date' },
salary: { bsonType: 'decimal' } // optional
}
}
}
});Enum Constraints: Restricting Allowed Values
The enum keyword restricts a field to a fixed list of permitted values. This is ideal for status fields, category codes, or any field that must come from a controlled vocabulary. Attempting to insert a value outside the enum list causes the write to fail with a validation error.
db.createCollection('tickets', {
validator: {
$jsonSchema: {
bsonType: 'object',
required: ['title', 'status', 'priority'],
properties: {
title: { bsonType: 'string' },
status: { enum: ['open', 'in_progress', 'resolved', 'closed'] },
priority: { enum: ['low', 'medium', 'high', 'critical'] }
}
}
}
});Numeric Range Constraints
For numeric fields, JSON Schema provides minimum, maximum, exclusiveMinimum, and exclusiveMaximum keywords. These work alongside bsonType to enforce valid ranges—for example, ensuring a product price is positive and a rating falls between 1 and 5.
db.createCollection('reviews', {
validator: {
$jsonSchema: {
bsonType: 'object',
required: ['productId', 'rating'],
properties: {
productId: { bsonType: 'objectId' },
rating: {
bsonType: 'int',
minimum: 1,
maximum: 5,
description: 'Rating must be between 1 and 5'
},
price: {
bsonType: 'decimal',
minimum: 0,
exclusiveMinimum: true
}
}
}
}
});String Length Constraints
String fields support minLength and maxLength to enforce character count limits. A username might need to be at least 3 characters and at most 30. A description field might have a 2000-character cap. These constraints prevent accidentally storing empty strings or truncated text that exceeds UI display limits.
db.createCollection('profiles', {
validator: {
$jsonSchema: {
bsonType: 'object',
required: ['username'],
properties: {
username: {
bsonType: 'string',
minLength: 3,
maxLength: 30,
description: 'Username must be 3-30 characters'
},
bio: {
bsonType: 'string',
maxLength: 500
}
}
}
}
});Pattern Constraints for Strings
The pattern keyword accepts a regular expression string and validates that the field value matches it. This is useful for enforcing email format, phone number patterns, UUID format, or slug conventions. Unlike regex queries used for search, pattern constraints run at write time to block non-conforming data from entering the collection.
db.runCommand({
collMod: 'users',
validator: {
$jsonSchema: {
bsonType: 'object',
required: ['email'],
properties: {
email: {
bsonType: 'string',
pattern: '^[a-zA-Z0-9._%+\\-]+@[a-zA-Z0-9.\\-]+\\.[a-zA-Z]{2,}$',
description: 'Must be a valid email address'
},
slug: {
bsonType: 'string',
pattern: '^[a-z0-9]+(?:-[a-z0-9]+)*$'
}
}
}
}
});Combining Type and Enum
Type and enum can be combined. Providing both bsonType and enum ensures the value is both of the correct type and within the allowed set. Without bsonType, an enum will accept any type that matches—including a number equal to the string value if JavaScript coercion were involved. Explicit types make validation intent clear.
properties: {
role: {
bsonType: 'string',
enum: ['admin', 'editor', 'viewer'],
description: 'Must be a string and one of the allowed roles'
}
}additionalProperties to Disallow Unknown Fields
By default, MongoDB validators allow any extra fields not mentioned in properties. Setting additionalProperties: false prevents documents from containing fields not declared in the schema. This is a strict mode that can catch typos in field names during development, though it can be too rigid for schemas that evolve frequently.
db.createCollection('strictUsers', {
validator: {
$jsonSchema: {
bsonType: 'object',
required: ['name', 'email'],
additionalProperties: false, // reject any undeclared fields
properties: {
_id: { bsonType: 'objectId' },
name: { bsonType: 'string' },
email: { bsonType: 'string' }
}
}
}
});Providing Helpful Error Descriptions
The description keyword inside each property definition is included in the validation error message returned to the client. Writing clear, human-readable descriptions like 'Email must be a valid address' or 'Rating must be between 1 and 5' makes it much easier for developers and API consumers to understand and fix validation failures without reading the schema.
Testing Your Validator
After adding a validator, always test it with both valid and invalid documents to confirm it behaves as expected. Try inserting a document missing a required field, a field with the wrong type, and a field with a value outside the enum. Also insert a perfectly valid document to confirm it is accepted. This two-sided testing prevents overly strict validators that block legitimate writes.
// Should FAIL — missing required 'email'
try { db.users.insertOne({ name: 'Bob' }); } catch(e) { console.log('Correctly rejected:', e.code); }
// Should FAIL — wrong type for 'age'
try { db.users.insertOne({ name: 'Bob', email: 'b@b.com', age: 'thirty' }); } catch(e) { console.log('Correctly rejected'); }
// Should PASS
db.users.insertOne({ name: 'Bob', email: 'b@b.com', age: 30 });
console.log('Valid document accepted');Quick Check
Test your understanding of MongoDB & NoSQL Databases concepts from this lesson.
Lesson Recap
In this lesson you learned: bsonType enforces BSON-specific data types including objectId and date, required declares mandatory fields at the schema level, and enum restricts a field to a fixed list of allowed values. Next up we explore validation levels and actions to control how strictly MongoDB enforces these rules.
Häufig gestellte Fragen
Ist die Lektion „Einschränkungen für Typ, Pflichtfelder und Enum“ kostenlos?
Ja — der vollständige Text von „Einschränkungen für Typ, Pflichtfelder und Enum“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des MongoDB Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der MongoDB Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Einschränkungen für Typ, Pflichtfelder und Enum“?
Definieren Sie innerhalb eines JSON-Schema-Validators Typbeschränkungen, Pflichtfelder und eine Aufzählung zulässiger Werte. Du übst MongoDB Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um MongoDB Academy zu starten?
Keine Vorkenntnisse erforderlich. MongoDB Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.
Wie lange dauert die Lektion „Einschränkungen für Typ, Pflichtfelder und Enum“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser MongoDB Academy-Lektion Code schreiben und ausführen?
Ja. Jede MongoDB Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Einen Validator zu einer Collection hinzufügen
- Einschränkungen für Typ, Pflichtfelder und Enum
- Validierungsstufen und Aktionen
- Schemas ohne Ausfallzeit weiterentwickeln