0Pricing
MongoDB Academy · Lektion

Was ist ein BSON-Dokument?

Lesen und schreiben Sie BSON-Dokumente in der MongoDB-Shell und erkennen Sie Feldtypen wie Strings, Zahlen, Arrays und verschachtelte Objekte.

Was ist ein BSON-Dokument? ist eine kostenlose MongoDB Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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.

JSON vs BSON: The Key Difference

You write MongoDB data as familiar JSON, but it's stored as BSON — binary JSON. It's faster to scan and supports richer types like dates and ObjectId.

The Structure of a BSON Document

A BSON document is just key-value pairs in curly braces, like a JS object. Every document needs an _id, and MongoDB auto-creates a unique one if you skip it.

// A minimal MongoDB document
{
  _id: ObjectId('64a2f3b1c9e7e12345678901'),
  name: 'Alice',
  age: 30,
  active: true
}
// _id is auto-generated if omitted on insert
// ObjectId encodes the insert timestamp in its first 4 bytes

String, Number, and Boolean Fields

Most fields look like JSON: strings, numbers, true/false, and null. One tip — for money, use Decimal128 to avoid floating-point rounding errors. The code shows how.

// Explicit BSON number types in mongosh
db.products.insertOne({
  name: 'Widget',
  quantity: NumberInt(100),       // 32-bit integer
  price: NumberDecimal('9.99'),   // Exact decimal for money
  weight: 0.45                    // Double (64-bit float)
});

The Date BSON Type

Date is a real BSON type, not a string. That lets you sort and range-query by date efficiently. Never store dates as plain text — you'd lose all of that.

// Always use BSON Date, not strings
db.events.insertOne({
  title: 'Conference',
  startDate: new Date('2024-09-01'),   // BSON Date
  endDate: ISODate('2024-09-03T18:00:00Z')
});

// Range query works perfectly on Date fields:
db.events.find({ startDate: { $gte: new Date('2024-01-01') } });

Nested Documents (Sub-Documents)

A field's value can be a whole document of its own — a nested document. An address fits naturally inside a user, and you query it with dot notation.

// Nested sub-document example
{
  _id: ObjectId('...'),
  name: 'Bob',
  address: {
    street: '123 Main St',
    city: 'Chicago',
    state: 'IL',
    zip: '60601'
  },
  employer: {
    name: 'Acme Corp',
    since: ISODate('2020-03-01')
  }
}

// Query by nested field:
db.users.find({ 'address.city': 'Chicago' });

Arrays in BSON Documents

Arrays let one field hold a list — tags, roles, or even sub-documents. MongoDB can index each element, so checking "does this contain X?" stays fast.

// Document with arrays of primitives and sub-documents
{
  _id: ObjectId('...'),
  productName: 'Smart TV',
  tags: ['electronics', '4K', 'HDR'],
  reviews: [
    { user: 'alice', rating: 5, comment: 'Love it!' },
    { user: 'bob',   rating: 4, comment: 'Good value.' }
  ]
}

// Query: documents where tags array contains '4K'
db.products.find({ tags: '4K' });

Binary Data and ObjectId

BSON also stores raw Binary data and the special ObjectId. Neat trick: an ObjectId hides its creation time in its first bytes, so _id roughly sorts by insert order.

// Extracting timestamp from ObjectId in mongosh
const id = ObjectId('64a2f3b1c9e7e12345678901');
console.log(id.getTimestamp());
// ISODate('2023-07-03T10:15:29.000Z')

// The first 8 hex chars = 4-byte timestamp
// 64a2f3b1 = Unix epoch seconds => 2023-07-03

Document Size Limit: 16 MB

Each document maxes out at 16 MB — huge for most data, and a nudge toward good modeling. For bigger files like videos, use GridFS, which splits them into chunks.

// GridFS upload example (Node.js driver)
const { GridFSBucket } = require('mongodb');
const bucket = new GridFSBucket(db, { bucketName: 'uploads' });

const uploadStream = bucket.openUploadStream('photo.jpg');
fs.createReadStream('/tmp/photo.jpg').pipe(uploadStream);
uploadStream.on('finish', () => console.log('Uploaded:', uploadStream.id));

Flexible Schema in Practice

MongoDB doesn't force a schema, so two documents in one collection can have different fields. This flexible schema is a gift during fast, early development.

// Two documents in the same collection with different shapes
// This is perfectly valid in MongoDB

// User with social login
{ _id: ObjectId('...'), name: 'Alice', googleId: 'g_12345', createdAt: new Date() }

// User with email/password
{ _id: ObjectId('...'), name: 'Bob', email: 'bob@test.com', passwordHash: 'bcrypt...', createdAt: new Date() }

Reading BSON in mongosh

The mongosh shell speaks a JavaScript-like syntax. Insert and it saves BSON; query and it prints clean, readable output with helpers like ObjectId and ISODate.

// mongosh: insert and read back
db.items.insertOne({ name: 'Chair', price: NumberDecimal('199.99'), createdAt: new Date() });

db.items.findOne({ name: 'Chair' });
// Output:
// {
//   _id: ObjectId('64a2f3b1...'),
//   name: 'Chair',
//   price: Decimal128('199.99'),
//   createdAt: ISODate('2024-01-15T10:23:00.000Z')
// }

BSON Serialization in Node.js

With the Node.js driver you just use plain JS objects — it handles BSON conversion for you. You never build binary by hand; numbers and dates just work.

const { ObjectId, Decimal128 } = require('mongodb');

// JS object -> BSON automatically by the driver
const doc = {
  _id: new ObjectId(),           // BSON ObjectId
  name: 'Widget',                // BSON String
  price: Decimal128.fromString('19.99'),  // BSON Decimal128
  stock: 100,                    // BSON Double (JS default)
  createdAt: new Date(),         // BSON Date
  tags: ['sale', 'new']          // BSON Array
};
await db.collection('products').insertOne(doc);

Quick Check

Test your understanding of MongoDB & NoSQL Databases concepts from this lesson.

Lesson Recap

You learned BSON extends JSON with richer types, that documents nest sub-documents and arrays, and that the schema is flexible. Next: collections vs SQL tables.

Häufig gestellte Fragen

Ist die Lektion „Was ist ein BSON-Dokument?“ kostenlos?

Ja — der vollständige Text von „Was ist ein BSON-Dokument?“ 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 „Was ist ein BSON-Dokument?“?

Lesen und schreiben Sie BSON-Dokumente in der MongoDB-Shell und erkennen Sie Feldtypen wie Strings, Zahlen, Arrays und verschachtelte Objekte. 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 1 von 4.

Wie lange dauert die Lektion „Was ist ein BSON-Dokument?“?

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

  1. Was ist ein BSON-Dokument?
  2. Collections und SQL-Tabellen im Vergleich
  3. Datenbanken, Collections und Namespaces
  4. Grundlagen der mongosh-Shell
← Zurück zu MongoDB Academy