Vad är BSON och vilka datatyper stöder MongoDB?

Question

Accepted Answer

**BSON** (Binary JSON) är det binära format som MongoDB använder för att lagra dokument — det utökar JSON med ytterligare **datatyper** (som datum, ObjectId, binär data och korrekta nummertyper) och är effektivt att lagra och traversera. Att förstå BSON-typer hjälper dig att lagra data korrekt.

## BSON — binär JSON med fler typer

```text
JSON has limited types (string, number, boolean, null, object, array).
BSON adds: ObjectId, Date, Binary, Decimal128, distinct Int/Long/Double, Timestamp, etc.
→ BSON is more efficient (binary, typed, traversable) and richer than plain JSON text.
```

## Vanliga BSON-datatyper

```js
{
  _id: ObjectId("..."),          // ObjectId — 12-byte unique id (the default _id type)
  name: "Ann",                    // String
  age: NumberInt(30),             // Int32 (32-bit integer)
  views: NumberLong(10000000000), // Int64 (64-bit — for large numbers)
  price: NumberDecimal("9.99"),   // Decimal128 — EXACT decimal (use for money!)
  rating: 4.5,                     // Double (default for numbers)
  active: true,                    // Boolean
  createdAt: ISODate("2024-01-15"),// Date (a proper date type, not a string)
  data: BinData(0, "..."),         // Binary data
  tags: ["a", "b"],                // Array
  address: { city: "NY" },          // Embedded document (object)
  deletedAt: null                   // Null
}
```

## ObjectId — standardvärdet _id

```js
// ObjectId is a 12-byte id: timestamp + machine/process + counter → globally unique
// It even encodes a creation timestamp:
ObjectId("...").getTimestamp();   // get when the document was created
```

**ObjectId** (standard `_id`) är unik och innehåller en tidsstämpel — så den är ungefär tidssorterad och du får skapelsetid gratis.

## Viktiga typöverväganden

```text
✓ Use proper DATE type (ISODate), not date strings → enables date queries/sorting
✓ Use Decimal128 (NumberDecimal) for MONEY → exact (avoid Double's rounding errors)
✓ Be aware of Int32 vs Int64 vs Double — numbers default to Double; large ints need Long
✓ ObjectId vs custom _id — you can use your own _id, but ObjectId is convenient/unique
```

## Varför det är viktigt

Att förstå BSON och Mongodbs datatyper är värdefullt för **att lagra data korrekt och effektivt**, så det är användbara grundläggande kunskaper för att arbeta med MongoDB.

Att veta att MongoDB använder **BSON** (binär JSON, rikare och mer effektiv än vanlig JSON) och **datatyperna det stöder** utöver grundläggande JSON — särskilt korrekta **Date**-typer, **ObjectId**, **Decimal128** och särskilda heltals-/double-typer — är viktigt för att representera data korrekt.

Flera typöverväganden är praktiskt viktiga: att använda en korrekt **Date-typ** (ISODate) istället för datumsträngar (möjliggör korrekta datumfrågor och sortering — ett vanligt misstag att lagra datum som strängar), att använda **Decimal128 (NumberDecimal) för pengar** (exakt decimalräkning, undviker avrundningsfel från Double — samma kritiska korrekthetsfel som i SQL) och att vara medveten om nummertypsärdomar (siffror är som standard Double; stora heltal behöver Int64/Long).

Att förstå **ObjectId** (standard `_id` — en 12-byte unik identifierare som bekvämt kodar en skapelsetidsstämpel, så den är ungefär tidssorterad och ger dig skapelsetid gratis) är användbar för att arbeta med dokumentidentifierare.

Eftersom lagring av data med rätt typer påverkar korrekthet (pengarkorrekthet, datuumfunktionalitet), effektivitet och frågbarhet, och eftersom Bsons rikare typsystem (särskilt Date, Decimal128 och ObjectId) är hur MongoDB representerar data korrekt, är att förstå BSON och Mongodbs datatyper — tillgängliga typer, pengar-/datumöverväganden och ObjectId — värdefullt, praktiskt relevant kunskap för att designa MongoDB-data korrekt och undvika vanliga typbeslaktade misstag (som strängdatum eller decimalpengar), en användbar aspekt av att arbeta effektivt med databasen.