¿Cómo insertar, actualizar y eliminar documentos?

Question

IT Interview Practice · Accepted Answer

MongoDB modifica datos con métodos **insert** (`insertOne`/`insertMany`), **update** (`updateOne`/`updateMany` con operadores) y **delete** (`deleteOne`/`deleteMany`). Las actualizaciones utilizan **operadores de actualización** en lugar de reemplazar documentos completos — una distinción importante.

## Insertar

```js
db.users.insertOne({ name: "Ann", age: 30 });          // → returns the inserted _id
db.users.insertMany([{ name: "Bob" }, { name: "Carol" }]);   // bulk insert (efficient)
```

## Actualizar con operadores (no reemplaces todo el documento)

```js
// updateOne — filter (which doc) + update (with OPERATORS)
db.users.updateOne(
  { name: "Ann" },
  { $set: { age: 31, status: "active" } }   // $set: change specific fields
);

// common update operators
{ $set: { field: value } }       // set/change a field
{ $unset: { field: "" } }         // remove a field
{ $inc: { count: 1 } }            // increment a number
{ $push: { tags: "new" } }        // add to an array
{ $pull: { tags: "old" } }        // remove from an array
{ $addToSet: { tags: "x" } }      // add to array only if not present
```

```js
db.users.updateMany({ active: false }, { $set: { archived: true } });  // update all matching
```

**Importante:** las actualizaciones utilizan **operadores** (`$set`, `$inc`, `$push`, etc.) para modificar *campos específicos*. Sin un operador, *reemplazarías todo el documento* — una trampa común:

```js
// ❌ this REPLACES the whole document (loses other fields!)
db.users.updateOne({ name: "Ann" }, { age: 31 });   // Ann now has ONLY age!
// ✅ use $set to change just the field
db.users.updateOne({ name: "Ann" }, { $set: { age: 31 } });
```

## Eliminar

```js
db.users.deleteOne({ name: "Ann" });          // delete the first match
db.users.deleteMany({ active: false });        // delete all matching
db.users.deleteMany({});                       // ⚠️ deletes ALL documents!
```

## Upsert — insertar si no se encuentra

```js
db.users.updateOne(
  { email: "ann@x.com" },
  { $set: { name: "Ann" } },
  { upsert: true }            // if no match, INSERT a new document
);
```

## Por qué es importante

Las operaciones de inserción, actualización y eliminación son cómo las aplicaciones **modifican datos** en MongoDB, fundamentales para cualquier aplicación basada en datos, así que comprenderlas es conocimiento esencial día a día.

Conocer los métodos (`insertOne`/`insertMany` para crear, `updateOne`/`updateMany` para modificar, `deleteOne`/`deleteMany` para eliminar) cubre lo básico.

El **punto más importante y frecuentemente malinterpretado** es que las actualizaciones de MongoDB utilizan **operadores de actualización** (`$set`, `$inc`, `$push`, `$pull`, etc.) para modificar *campos específicos* — y crucialmente, **olvidar el operador reemplaza todo el documento** (una trampa notoria donde `updateOne({...}, {age: 31})` borra todos los demás campos, dejando solo `age`), así que entender usar siempre `$set` (y los otros operadores) para actualizaciones a nivel de campo es esencial para la corrección.

Conocer los operadores comunes (`$set`, `$inc` para contadores, `$push`/`$pull`/`$addToSet` para arrays — siendo los operadores de array especialmente relevantes dada la riqueza de arrays en los documentos de MongoDB) es conocimiento esencial día a día.

Comprender **upsert** (`{ upsert: true }` — insertar si no existe coincidencia, la forma de insert-or-update de MongoDB) es valioso para el patrón común de insertar o actualizar.

También vale la pena notar el peligro de `deleteMany({})` (eliminar todo — similar al peligro de WHERE faltante en SQL).

Puesto que modificar datos es fundamental, y puesto que las actualizaciones basadas en operadores de MongoDB (con la trampa de reemplazo de documento), operadores de array y upsert son cómo cambias datos correctamente, entender inserción/actualización/eliminación — especialmente la distinción crítica de operador de actualización (evitando reemplazo accidental de documento) — es conocimiento esencial, imprescindible para cualquier desarrollo en MongoDB, donde la trampa de operador en particular es una fuente frecuente de bugs reales.

Insertar

Actualizar con operadores (no reemplaces todo el documento)

Eliminar

Upsert — insertar si no se encuentra

Por qué es importante

Preguntas relacionadas