Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/tutosrive/db-nosql-2026-1/llms.txt

Use this file to discover all available pages before exploring further.

Los operadores de actualización de MongoDB permiten modificar documentos existentes en una colección de forma precisa y eficiente. En lugar de reemplazar un documento completo, estos operadores actúan sobre campos individuales: establecen valores, incrementan contadores, añaden o eliminan elementos de arreglos, e incluso permiten ejecutar expresiones de pipeline para calcular valores dinámicamente en el momento de la actualización.

​
Operadores de Campo

Los operadores de campo modifican propiedades escalares de un documento.
Al pasar un objeto {} como segundo argumento de updateMany, MongoDB lo interpreta como un conjunto de operadores de actualización (p. ej. $set). Al pasar un arreglo [], MongoDB lo interpreta como un pipeline de agregación. La diferencia es importante: solo el pipeline permite usar expresiones dinámicas que referencian campos del propio documento.

​
$set — Establecer o agregar campos

// $set: establecer o agregar un campo simple
db.users.updateMany({}, { $set: { activo: true } })

// $set con objeto anidado (2 niveles)
db.users.updateMany({}, {
  $set: {
    estado: {
      descripción: "activo",
      actualizado: "Hace 1 hora"
    }
  }
})

// $set con 3 niveles de anidación
db.users.updateMany({}, {
  $set: {
    estado: {
      descripción: "activo",
      actualizado: "Hace 1 hora",
      detalles: { detalle: "Creado por Santiago" }
    }
  }
})

​
$unset — Eliminar un campo

// $unset: eliminar un campo del documento
db.users.updateMany({}, { $unset: { campoAntiguo: "" } })
El valor que se le pasa al campo dentro de $unset no importa; por convención se usa "". Lo que importa es la clave: el campo con ese nombre será eliminado del documento.

​
$inc — Incrementar un campo numérico

// $inc: incrementar puntos_acumulados en 10 para todos los usuarios
db.users.updateMany({}, { $inc: { puntos_acumulados: 10 } })
$inc también acepta valores negativos para decrementar.

​
Tabla de operadores de campo

OperadorDescripción
$setEstablece el valor de un campo. Si no existe, lo crea.
$unsetElimina un campo del documento.
$incIncrementa (o decrementa) un campo numérico.
$renameRenombra un campo.
$mulMultiplica el valor de un campo por un número.

​
Operadores de Arreglo

Cuando un campo contiene un arreglo, los siguientes operadores permiten agregar, eliminar o actualizar sus elementos.

​
$set para establecer un arreglo completo

// Asignar un arreglo de aficiones a un usuario
db.users.updateOne(
  { nombre: "Paula Rojas" },
  { $set: { aficiones: ["catar", "bailar", "presentar"] } }
)

​
$push — Agregar un elemento al arreglo

// $push: añadir "leer" al arreglo aficiones
db.users.updateOne(
  { nombre: "Paula Rojas" },
  { $push: { aficiones: "leer" } }
)

​
$pull — Eliminar elementos del arreglo

// $pull: eliminar "catar" del arreglo aficiones
db.users.updateOne(
  { nombre: "Paula Rojas" },
  { $pull: { aficiones: "catar" } }
)

​
$addToSet — Agregar si no existe

// $addToSet: agregar "bailar" solo si no está ya en el arreglo
db.users.updateOne(
  { nombre: "Paula Rojas" },
  { $addToSet: { aficiones: "bailar" } }
)
OperadorDescripción
$pushAgrega un elemento al final del arreglo, incluso si ya existe.
$pullElimina todos los elementos que coincidan con el valor dado.
$addToSetAgrega un elemento solo si no está ya presente (evita duplicados).
$popElimina el primer (-1) o el último (1) elemento del arreglo.

​
Actualización con Pipeline

Cuando el valor que se quiere asignar depende de otro campo del mismo documento, el objeto {} de actualización no es suficiente: es necesario pasar un arreglo de etapas (pipeline de agregación) como segundo argumento de updateMany o updateOne. 
// Calcular y actualizar la edad desde la fecha de nacimiento
db.personas.updateMany(
  {},
  [{
    $set: {
      "dob.age": {
        $toInt: {
          $dateDiff: {
            startDate: {
              $dateFromString: { dateString: "$dob.date" }
            },
            endDate: "$$NOW",
            unit: "year"
          }
        }
      }
    }
  }]
)
Este comando es el ejercicio 2 del curso: actualizar el campo dob.age de todos los documentos de la colección personas para que refleje la edad real calculada desde dob.date hasta la fecha actual del servidor.
$$NOW es una variable de sistema de MongoDB que representa el instante actual del servidor en el momento en que se ejecuta la operación. Al ser evaluada en el servidor, garantiza que todos los documentos de una misma operación updateMany usan exactamente el mismo timestamp de referencia, sin importar cuántos documentos se actualicen.

​
Operadores de Fecha

MongoDB proporciona operadores de expresión de fecha que se pueden usar dentro de pipelines de agregación o de actualización.
OperadorDescripción
$dateDiffCalcula la diferencia entre dos fechas en la unidad indicada
$dateFromStringConvierte un string ISO en un objeto Date de MongoDB
$toIntConvierte un valor a entero (útil para truncar el resultado de $dateDiff)
$$NOWVariable de sistema: fecha y hora actuales del servidor

​
Unidades válidas para $dateDiff

UnidadDescripción
"year"Años
"quarter"Trimestres
"month"Meses
"week"Semanas
"day"Días
"hour"Horas
"minute"Minutos
"second"Segundos

​
Ejemplo en aggregate — Ver diferencia de años por persona

db.personas.aggregate(
  {
    $project: {
      name: "$name.first",
      date: "$dob.date",
      yearsDiff: {
        $toInt: {
          $dateDiff: {
            startDate: { $dateFromString: { dateString: "$dob.date" } },
            endDate: "$$NOW",
            unit: "year"
          }
        }
      }
    }
  },
  { $limit: 1 }
)
Este aggregate es útil para verificar el resultado antes de lanzar el updateMany: muestra cómo quedaría el campo dob.age calculado para el primer documento de la colección.

​
Ejercicio: Actualizar Edades a la Fecha Actual

1

Verificar la estructura del documento

Antes de actualizar, inspeccionar el documento para confirmar el formato del campo dob.date.
db.personas.findOne({}, { "dob.date": 1, "dob.age": 1 })
2

Probar el cálculo con aggregate

Usar un pipeline de agregación con $limit: 1 para ver cómo quedaría el valor calculado sin modificar nada.
db.personas.aggregate(
  {
    $project: {
      name: "$name.first",
      date: "$dob.date",
      yearsDiff: {
        $toInt: {
          $dateDiff: {
            startDate: { $dateFromString: { dateString: "$dob.date" } },
            endDate: "$$NOW",
            unit: "year"
          }
        }
      }
    }
  },
  { $limit: 1 }
)
3

Ejecutar el updateMany con pipeline

Una vez verificado el cálculo, ejecutar la actualización sobre todos los documentos.
db.personas.updateMany(
  {},
  [{
    $set: {
      "dob.age": {
        $toInt: {
          $dateDiff: {
            startDate: {
              $dateFromString: { dateString: "$dob.date" }
            },
            endDate: "$$NOW",
            unit: "year"
          }
        }
      }
    }
  }]
)
4

Verificar el resultado

Confirmar que el campo dob.age fue actualizado correctamente.
db.personas.findOne({}, { "dob.date": 1, "dob.age": 1 })
Este comando modifica todos los documentos de la colección personas. Asegúrate de ejecutarlo en el entorno correcto y de tener un respaldo si la colección contiene datos de producción.

Build docs developers (and LLMs) love

Get started for freeTalk to us