Consultar arrays de MongoDB

MongoDBMongoDBBeginner
Practicar Ahora

💡 Este tutorial está traducido por IA desde la versión en inglés. Para ver la versión original, puedes hacer clic aquí

Introducción

En este laboratorio, aprenderá a consultar eficazmente los arrays de MongoDB. El laboratorio aborda varias técnicas, como buscar elementos específicos dentro de los arrays, utilizar operadores de array para consultas más complejas, encontrar documentos por tamaño de array, coincidir con posiciones de elementos y filtrar valores de array. Estas habilidades son esenciales para trabajar con las poderosas estructuras de datos proporcionadas por MongoDB, lo que le permite recuperar y manipular eficientemente los datos almacenados en campos de array.

El laboratorio lo guía a través de ejemplos prácticos, comenzando con la creación de una colección de muestra y luego explorando diferentes métodos de consulta. Al final de este laboratorio, tendrá una sólida comprensión de cómo aprovechar las capacidades de consulta de arrays de MongoDB para satisfacer sus necesidades de gestión de datos.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL mongodb(("MongoDB")) -.-> mongodb/QueryOperationsGroup(["Query Operations"]) mongodb(("MongoDB")) -.-> mongodb/DataTypesGroup(["Data Types"]) mongodb(("MongoDB")) -.-> mongodb/ArrayandEmbeddedDocumentsGroup(["Array and Embedded Documents"]) mongodb/QueryOperationsGroup -.-> mongodb/find_documents("Find Documents") mongodb/DataTypesGroup -.-> mongodb/work_with_array_data_types("Work with Array Data Types") mongodb/DataTypesGroup -.-> mongodb/manage_array_elements("Manage Array Elements") mongodb/ArrayandEmbeddedDocumentsGroup -.-> mongodb/query_embedded_documents("Query Embedded Documents") subgraph Lab Skills mongodb/find_documents -.-> lab-422090{{"Consultar arrays de MongoDB"}} mongodb/work_with_array_data_types -.-> lab-422090{{"Consultar arrays de MongoDB"}} mongodb/manage_array_elements -.-> lab-422090{{"Consultar arrays de MongoDB"}} mongodb/query_embedded_documents -.-> lab-422090{{"Consultar arrays de MongoDB"}} end

Buscar elementos de un array

En este paso, exploraremos cómo buscar elementos dentro de los arrays de MongoDB. Los arrays son estructuras de datos poderosas que te permiten almacenar múltiples valores en un solo campo, y MongoDB ofrece maneras flexibles de consultar estos arrays.

Primero, iniciemos la shell de MongoDB y creemos una colección de muestra con datos de array:

mongosh

Ahora, creemos una base de datos e insertemos algunos documentos con campos de array:

use arraylab

db.products.insertMany([
    {
        name: "Laptop",
        tags: ["electronics", "computer", "work"],
        colors: ["silver", "black", "blue"]
    },
    {
        name: "Smartphone",
        tags: ["electronics", "mobile", "communication"],
        colors: ["red", "blue", "green"]
    },
    {
        name: "Headphones",
        tags: ["electronics", "audio", "music"],
        colors: ["black", "white"]
    }
])

Busquemos documentos que contengan un elemento específico en un array:

db.products.find({ tags: "electronics" });

Esta consulta devolverá todos los documentos donde "electronics" está presente en el array tags.

Salida de ejemplo:

[
  {
    _id: ObjectId("..."),
    name: 'Laptop',
    tags: [ 'electronics', 'computer', 'work' ],
    colors: [ 'silver', 'black', 'blue' ]
  },
  {
    _id: ObjectId("..."),
    name: 'Smartphone',
    tags: [ 'electronics','mobile', 'communication' ],
    colors: [ 'red', 'blue', 'green' ]
  },
  {
    _id: ObjectId("..."),
    name: 'Headphones',
    tags: [ 'electronics', 'audio','music' ],
    colors: [ 'black', 'white' ]
  }
]

También puedes buscar documentos donde un array contiene múltiples elementos específicos:

db.products.find({ colors: { $all: ["black", "blue"] } });

Esta consulta encuentra los productos que tienen tanto "black" como "blue" en su array colors.

Usar operadores de array

En este paso, profundizaremos en la consulta de arrays de MongoDB explorando poderosos operadores de array que permiten búsquedas más complejas y precisas.

Continuaremos utilizando la base de datos y la colección del paso anterior. Si has cerrado la shell de MongoDB, inténtala de nuevo y selecciona la base de datos:

mongosh
use arraylab

Comencemos por aprender sobre el operador $elemMatch, que permite coincidir documentos donde al menos un elemento de array cumpla múltiples condiciones:

db.products.insertMany([
  {
    name: "Gaming Laptop",
    specs: [
      { ram: 16, storage: 512, price: 1200 },
      { ram: 32, storage: 1024, price: 2000 }
    ]
  },
  {
    name: "Office Laptop",
    specs: [
      { ram: 8, storage: 256, price: 600 },
      { ram: 16, storage: 512, price: 800 }
    ]
  }
]);

// Encuentra laptops con especificaciones que tengan RAM >= 16 y precio > 1000
db.products.find({
  specs: {
    $elemMatch: {
      ram: { $gte: 16 },
      price: { $gt: 1000 }
    }
  }
});

A continuación, exploremos el operador $size para encontrar documentos con arrays de una longitud específica:

// Encuentra productos con exactamente 2 colores
db.products.find({ colors: { $size: 2 } });

También demostraremos el operador $slice para recuperar un subconjunto de elementos de array:

// Recupera solo los primeros dos tags de cada producto
db.products.find({}, { tags: { $slice: 2 } });

Salida de ejemplo:

[
  {
    _id: ObjectId("..."),
    name: 'Laptop',
    tags: [ 'electronics', 'computer' ]
  },
  {
    _id: ObjectId("..."),
    name: 'Smartphone',
    tags: [ 'electronics','mobile' ]
  }
]

Buscar por tamaño de array

En este paso, exploraremos cómo consultar documentos de MongoDB basados en el tamaño de sus arrays. El operador $size te permite encontrar documentos con arrays que tienen un número específico de elementos.

Primero, iniciemos la shell de MongoDB y asegúremos de que estamos usando nuestra base de datos anterior:

mongosh
use arraylab

Agregemos algunos documentos más con tamaños de array variados para demostrar nuestras consultas:

db.products.insertMany([
  {
    name: "Basic Laptop",
    features: ["wifi"],
    accessories: ["charger"]
  },
  {
    name: "Advanced Laptop",
    features: ["wifi", "bluetooth", "touchscreen"],
    accessories: ["charger", "mouse", "case"]
  },
  {
    name: "Premium Laptop",
    features: ["wifi", "bluetooth", "touchscreen", "4K display"],
    accessories: ["charger", "mouse", "case", "keyboard"]
  }
]);

Ahora, consultemos documentos con arrays de tamaños específicos:

// Encuentra productos con exactamente 1 característica
db.products.find({ features: { $size: 1 } });

// Encuentra productos con 3 características
db.products.find({ features: { $size: 3 } });

// Encuentra productos con 4 accesorios
db.products.find({ accessories: { $size: 4 } });

Salida de ejemplo:

// Productos con 1 característica
[
  {
    _id: ObjectId("..."),
    name: 'Basic Laptop',
    features: [ 'wifi' ],
    accessories: [ 'charger' ]
  }
]

// Productos con 3 características
[
  {
    _id: ObjectId("..."),
    name: 'Advanced Laptop',
    features: [ 'wifi', 'bluetooth', 'touchscreen' ],
    accessories: [ 'charger','mouse', 'case' ]
  }
]

// Productos con 4 accesorios
[
  {
    _id: ObjectId("..."),
    name: 'Premium Laptop',
    features: [ 'wifi', 'bluetooth', 'touchscreen', '4K display' ],
    accessories: [ 'charger','mouse', 'case', 'keyboard' ]
  }
]

También puedes combinar el operador $size con otras condiciones de consulta:

// Encuentra productos con exactamente 3 características y más de 2 accesorios
db.products.find({
  features: { $size: 3 },
  accessories: { $size: { $gt: 2 } }
});

Coincidir con la posición del elemento

En este paso, aprenderemos cómo consultar arrays de MongoDB al coincidir con posiciones específicas de los elementos. MongoDB ofrece maneras poderosas de buscar elementos en ubicaciones exactas dentro de un array.

Primero, iniciemos la shell de MongoDB y aseguremos de que estamos usando nuestra base de datos anterior:

mongosh
use arraylab

Cree una nueva colección con documentos que tengan arrays donde la posición de los elementos importa:

db.courses.insertMany([
  {
    name: "Web Development Bootcamp",
    modules: ["HTML", "CSS", "JavaScript", "React", "Node.js"],
    difficulty: ["beginner", "intermediate", "advanced"]
  },
  {
    name: "Data Science Course",
    modules: [
      "Python",
      "Statistics",
      "Machine Learning",
      "Deep Learning",
      "AI"
    ],
    difficulty: ["intermediate", "advanced", "expert"]
  },
  {
    name: "Cybersecurity Program",
    modules: [
      "Network Security",
      "Ethical Hacking",
      "Cryptography",
      "Penetration Testing",
      "Incident Response"
    ],
    difficulty: ["intermediate", "advanced", "expert"]
  }
]);

Ahora, consultemos documentos al coincidir con elementos en posiciones específicas de array:

// Encuentra cursos donde el primer módulo es "HTML"
db.courses.find({ "modules.0": "HTML" });

// Encuentra cursos donde el tercer módulo es "JavaScript"
db.courses.find({ "modules.2": "JavaScript" });

// Encuentra cursos donde el segundo nivel de dificultad es "advanced"
db.courses.find({ "difficulty.1": "advanced" });

Salida de ejemplo:

// Cursos con HTML como primer módulo
[
  {
    _id: ObjectId("..."),
    name: 'Web Development Bootcamp',
    modules: [ 'HTML', 'CSS', 'JavaScript', 'React', 'Node.js' ],
    difficulty: [ 'beginner', 'intermediate', 'advanced' ]
  }
]

// Cursos con JavaScript como tercer módulo
[
  {
    _id: ObjectId("..."),
    name: 'Web Development Bootcamp',
    modules: [ 'HTML', 'CSS', 'JavaScript', 'React', 'Node.js' ],
    difficulty: [ 'beginner', 'intermediate', 'advanced' ]
  }
]

// Cursos con "advanced" como segundo nivel de dificultad
[
  {
    _id: ObjectId("..."),
    name: 'Data Science Course',
    modules: [ 'Python', 'Statistics', 'Machine Learning', 'Deep Learning', 'AI' ],
    difficulty: [ 'intermediate', 'advanced', 'expert' ]
  },
  {
    _id: ObjectId("..."),
    name: 'Cybersecurity Program',
    modules: [ 'Network Security', 'Ethical Hacking', 'Cryptography', 'Penetration Testing', 'Incident Response' ],
    difficulty: [ 'intermediate', 'advanced', 'expert' ]
  }
]

También puedes combinar consultas basadas en posición con otras condiciones:

// Encuentra cursos donde el primer módulo es "HTML" y la segunda dificultad es "intermediate"
db.courses.find({
  "modules.0": "HTML",
  "difficulty.1": "intermediate"
});

Filtrar valores de array

En este último paso, exploraremos técnicas avanzadas para filtrar valores de array en MongoDB, utilizando operadores de comparación y lógicos para crear consultas complejas.

Primero, iniciemos la shell de MongoDB y aseguremos de que estamos usando nuestra base de datos anterior:

mongosh
use arraylab

Cree una colección de productos con estructuras de array más complejas:

db.electronics.insertMany([
  {
    name: "Smartphone",
    specs: [
      { ram: 6, storage: 128, price: 499 },
      { ram: 8, storage: 256, price: 599 }
    ],
    tags: ["mobile", "communication", "high-end"],
    ratings: [4.5, 4.7, 4.6]
  },
  {
    name: "Laptop",
    specs: [
      { ram: 16, storage: 512, price: 1200 },
      { ram: 32, storage: 1024, price: 2000 }
    ],
    tags: ["computer", "work", "professional"],
    ratings: [4.8, 4.9, 4.7]
  },
  {
    name: "Tablet",
    specs: [
      { ram: 4, storage: 64, price: 299 },
      { ram: 8, storage: 256, price: 499 }
    ],
    tags: ["mobile", "entertainment"],
    ratings: [4.2, 4.3, 4.1]
  }
]);

Explore diferentes técnicas de filtrado:

  1. Filtrar por comparación de elementos de array:
// Encuentra dispositivos con al menos una especificación que tenga RAM >= 16
db.electronics.find({
  specs: {
    $elemMatch: { ram: { $gte: 16 } }
  }
});

// Encuentra dispositivos con calificaciones por encima de 4.5
db.electronics.find({
  ratings: { $gt: 4.5 }
});
  1. Usar operadores lógicos con arrays:
// Encuentra dispositivos con ambas etiquetas "mobile" y "communication"
db.electronics.find({
  tags: { $all: ["mobile", "communication"] }
});

// Encuentra dispositivos con alguna de las etiquetas "work" o "entertainment"
db.electronics.find({
  tags: { $in: ["work", "entertainment"] }
});
  1. Filtrado complejo con múltiples condiciones:
// Encuentra dispositivos con especificaciones que tengan RAM >= 8 y precio <= 1000
db.electronics.find({
  specs: {
    $elemMatch: {
      ram: { $gte: 8 },
      price: { $lte: 1000 }
    }
  }
});

Salida de ejemplo:

// Dispositivos con RAM >= 16
[
  {
    _id: ObjectId("..."),
    name: 'Laptop',
    specs: [
      { ram: 16, storage: 512, price: 1200 },
      { ram: 32, storage: 1024, price: 2000 }
    ],
    tags: [ 'computer', 'work', 'professional' ],
    ratings: [ 4.8, 4.9, 4.7 ]
  }
]

// Dispositivos con calificaciones por encima de 4.5
[
  {
    _id: ObjectId("..."),
    name: 'Smartphone',
    ratings: [ 4.5, 4.7, 4.6 ]
  },
  {
    _id: ObjectId("..."),
    name: 'Laptop',
    ratings: [ 4.8, 4.9, 4.7 ]
  }
]

Resumen

En este laboratorio, aprendiste cómo buscar elementos dentro de arrays de MongoDB, utilizando diversos operadores de array para realizar búsquedas más complejas y precisas. Exploraste técnicas para encontrar documentos basados en la presencia de elementos específicos en un array, así como el tamaño y la posición de los elementos de array. Estas habilidades te permiten consultar y manipular eficazmente los datos almacenados en las estructuras de datos de array flexibles de MongoDB, lo que te permite construir aplicaciones poderosas y eficientes.