menu FixWins.com apps Spring MVC Spring Boot Angular Laravel MongoDB ExpressJS ReactJS list

Les opérateurs : $and,$or,$not,$ne,$nor

Exemples
Exemples avec find et findOne
Supposons une collection appelée users avec des documents ayant des champs name, age, et city.
find avec $and: 

db.users.find({
  $and: [
    { name: "John" },
    { age: { $gt: 25 } }
  ]
});
findOne avec $and: 

db.users.findOne({
  $and: [
    { name: "Alice" },
    { city: "New York" }
  ]
});
Exemples avec delete et deleteOne
Supposons que vous vouliez supprimer des utilisateurs en fonction de certains critères.
delete avec $and: 

db.users.deleteMany({
  $and: [
    { name: "Bob" },
    { age: { $lt: 30 } }
  ]
});
deleteOne avec $and: 

db.users.deleteOne({
  $and: [
    { name: "Eve" },
    { city: "Paris" }
  ]
});
Exemples avec update et updateMany
Supposons que vous vouliez mettre à jour des documents en fonction de certains critères.
update avec $and: 

db.users.updateMany({
  $and: [
    { name: "Charlie" },
    { age: { $gte: 21 } }
  ]
},
{
  $set: { status: "active" }
});
updateMany avec $and: 

db.users.updateMany({
  $and: [
    { city: "London" },
    { age: { $gte: 18 } }
  ]
},
{
  $set: { canDrinkAlcohol: true }
});
Exemples avec aggregate
aggregate avec $and

db.users.aggregate([
  {
    $match: {
      $and: [
        { profession: "Engineer" },
        { experience: { $gte: 5 } }
      ]
    }
  },
  {
    $group: {
      _id: "$profession",
      averageAge: { $avg: "$age" }
    }
  }
]);
Considérons une collection "employees" avec des documents qui ressemblent à ceci : 

{
  "_id": ObjectId("60a0c8c0f09a9b04789d13c4"),
  "name": "John Doe",
  "age": 30,
  "position": "Developer",
  "skills": ["JavaScript", "MongoDB", "Node.js"],
  "projects": [
    {
      "name": "Project A",
      "duration": 6
    },
    {
      "name": "Project B",
      "duration": 8
    }
  ],
  "salary": 80000
}
Exemples avec find et findOne
find avec $and: 

db.employees.find({
  $and: [
    { "name": "John Doe" },
    { "age": { $gt: 25 } }
  ]
});
findOne avec $and: 

db.employees.findOne({
  $and: [
    { "position": "Developer" },
    { "skills": "MongoDB" }
  ]
});
Exemples avec delete et deleteOne
delete avec $and: 

db.employees.deleteMany({
  $and: [
    { "name": "John Doe" },
    { "age": { $gt: 30 } }
  ]
});
deleteOne avec $and: 

db.employees.deleteOne({
  $and: [
    { "position": "Developer" },
    { "projects.name": "Project A" }
  ]
});
Exemples avec update et updateMany
update avec $and: 

db.employees.updateMany({
  $and: [
    { "position": "Developer" },
    { "age": { $gte: 25 } }
  ]
},
{
  $set: { "salary": 90000 }
});
updateMany avec $and: 

db.employees.updateMany({
  $and: [
    { "projects.name": "Project B" },
    { "projects.duration": { $gte: 8 } }
  ]
},
{
  $inc: { "salary": 5000 }
});
Exemples avec aggregate
aggregate avec $and: 

db.employees.aggregate([
  {
    $match: {
      $and: [
        { "position": "Developer" },
        { "age": { $gte: 30 } }
      ]
    }
  },
  {
    $group: {
      _id: "$position",
      averageSalary: { $avg: "$salary" }
    }
  }
]);
Supposons une collection "products" avec des documents qui ressemblent à ceci : 

{
  "_id": ObjectId("60a0c8c0f09a9b04789d13c5"),
  "name": "Laptop",
  "category": "Electronics",
  "price": 1200,
  "availability": true,
  "reviews": [
    {
      "user": "User1",
      "rating": 4
    },
    {
      "user": "User2",
      "rating": 5
    }
  ],
  "tags": ["High-performance", "Slim", "Portable"]
}
Exemples avec find et findOne
find avec $and pour filtrer les produits disponibles dans une certaine catégorie avec un prix inférieur à 1500 : 

db.products.find({
  $and: [
    { "category": "Electronics" },
    { "price": { $lt: 1500 } },
    { "availability": true }
  ]
});
findOne avec $and pour trouver un produit avec une certaine étiquette et une note de revue spécifique : 

db.products.findOne({
  $and: [
    { "tags": "Slim" },
    { "reviews.rating": { $gte: 4 } }
  ]
});
Exemples avec delete et deleteOne
delete avec $and pour supprimer des produits dans une certaine catégorie avec un prix inférieur à 1000 : 

db.products.deleteMany({
  $and: [
    { "category": "Clothing" },
    { "price": { $lt: 1000 } }
  ]
});
deleteOne avec $and pour supprimer une étiquette spécifique d'un produit : 

db.products.deleteOne({
  $and: [
    { "name": "Laptop" },
    { "tags": "Portable" }
  ]
});
Exemples avec update et updateMany
update avec $and pour augmenter le prix des produits dans une certaine catégorie avec une note de revue inférieure à 3 : 

db.products.updateMany({
  $and: [
    { "category": "Clothing" },
    { "reviews.rating": { $lt: 3 } }
  ]
},
{
  $mul: { "price": 1.1 } // Augmente le prix de 10%
});
updateMany avec $and pour ajouter une nouvelle critique à un produit avec une certaine étiquette : 

db.products.updateMany({
  $and: [
    { "tags": "High-performance" },
    { "availability": true }
  ]
},
{
  $push: {
    "reviews": {
      "user": "User3",
      "rating": 4
    }
  }
});
Exemples avec aggregate
aggregate avec $and pour calculer la moyenne des prix des produits dans une certaine catégorie avec une note de revue supérieure à 4 : 

db.products.aggregate([
  {
    $match: {
      $and: [
        { "category": "Electronics" },
        { "reviews.rating": { $gte: 4 } }
      ]
    }
  },
  {
    $group: {
      _id: "$category",
      averagePrice: { $avg: "$price" }
    }
  }
]);
Supposons une collection "orders" avec des documents qui ressemblent à ceci : 

{
  "_id": ObjectId("60a0c8c0f09a9b04789d13c6"),
  "customer": {
    "name": "Alice",
    "age": 28,
    "loyaltyPoints": 150
  },
  "products": [
    {
      "name": "Smartphone",
      "price": 500
    },
    {
      "name": "Headphones",
      "price": 100
    }
  ],
  "orderDate": ISODate("2023-01-01T08:00:00Z"),
  "status": "Shipped"
}
Exemples avec find et findOne
find avec $and pour trouver des commandes d'un client particulier avec un certain statut : 

db.orders.find({
  $and: [
    { "customer.name": "Alice" },
    { "status": "Shipped" }
  ]
});
findOne avec $and pour trouver une commande avec une date spécifique et un prix total inférieur à 600 : 

db.orders.findOne({
  $and: [
    { "orderDate": ISODate("2023-01-01T08:00:00Z") },
    {
      $expr: {
        $lt: [
          { $sum: "$products.price" },
          600
        ]
      }
    }
  ]
});
Exemples avec delete et deleteOne
delete avec $and pour supprimer des commandes expédiées d'un client spécifique : 

db.orders.deleteMany({
  $and: [
    { "status": "Shipped" },
    { "customer.name": "Bob" }
  ]
});
deleteOne avec $and pour supprimer un produit spécifique d'une commande : 

db.orders.deleteOne({
  $and: [
    { "products.name": "Headphones" },
    { "status": "Pending" }
  ]
});
Exemples avec update et updateMany
update avec $and pour mettre à jour le statut des commandes expédiées d'un client particulier : 

db.orders.updateMany({
  $and: [
    { "status": "Shipped" },
    { "customer.name": "Alice" }
  ]
},
{
  $set: { "status": "Delivered" }
});
updateMany avec $and pour ajouter des points de fidélité à un client en fonction du montant total de ses commandes : 

db.orders.updateMany({
  $and: [
    { "customer.name": "Alice" },
    {
      $expr: {
        $gte: [
          { $sum: "$products.price" },
          500
        ]
      }
    }
  ]
},
{
  $inc: { "customer.loyaltyPoints": 50 }
});
Exemples avec aggregate
aggregate avec $and pour calculer le montant total des commandes expédiées par catégorie de produits : 

db.orders.aggregate([
  {
    $match: {
      $and: [
        { "status": "Shipped" },
        { "products.name": { $in: ["Smartphone", "Laptop"] } }
      ]
    }
  },
  {
    $group: {
      _id: "$status",
      totalAmount: { $sum: { $sum: "$products.price" } }
    }
  }
]);
Exemples avec find et findOne
find avec $or pour trouver des commandes d'un client particulier avec un certain statut : 

db.orders.find({
  $or: [
    { "customer.name": "Alice" },
    { "status": "Shipped" }
  ]
});
findOne avec $or pour trouver une commande avec une date spécifique ou un prix total inférieur à 600 : 

db.orders.findOne({
  $or: [
    { "orderDate": ISODate("2023-01-01T08:00:00Z") },
    {
      $expr: {
        $lt: [
          { $sum: "$products.price" },
          600
        ]
      }
    }
  ]
});
Exemples avec delete et deleteOne
delete avec $or pour supprimer des commandes expédiées d'un client spécifique : 

db.orders.deleteMany({
  $or: [
    { "status": "Shipped" },
    { "customer.name": "Bob" }
  ]
});
deleteOne avec $or pour supprimer un produit spécifique d'une commande : 

db.orders.deleteOne({
  $or: [
    { "products.name": "Headphones" },
    { "status": "Pending" }
  ]
});
Exemples avec update et updateMany
update avec $or pour mettre à jour le statut des commandes expédiées d'un client particulier : 

db.orders.updateMany({
  $or: [
    { "status": "Shipped" },
    { "customer.name": "Alice" }
  ]
},
{
  $set: { "status": "Delivered" }
});
updateMany avec $or pour ajouter des points de fidélité à un client en fonction du montant total de ses commandes : 

db.orders.updateMany({
  $or: [
    { "customer.name": "Alice" },
    {
      $expr: {
        $gte: [
          { $sum: "$products.price" },
          500
        ]
      }
    }
  ]
},
{
  $inc: { "customer.loyaltyPoints": 50 }
});
Exemples avec aggregate
aggregate avec $or pour calculer le montant total des commandes expédiées par catégorie de produits : 

db.orders.aggregate([
  {
    $match: {
      $or: [
        { "status": "Shipped" },
        { "products.name": { $in: ["Smartphone", "Laptop"] } }
      ]
    }
  },
  {
    $group: {
      _id: "$status",
      totalAmount: { $sum: { $sum: "$products.price" } }
    }
  }
]);
Supposons toujours une collection "products" avec des documents qui ressemblent à ceci : 

{
  "_id": ObjectId("60a0c8c0f09a9b04789d13c7"),
  "name": "Television",
  "category": "Electronics",
  "price": 800,
  "availability": true,
  "reviews": [
    {
      "user": "User1",
      "rating": 5
    },
    {
      "user": "User2",
      "rating": 4
    }
  ],
  "tags": ["Smart", "4K", "Large"]
}
Exemples avec find et findOne
find avec $or pour trouver des produits dans une certaine catégorie ou avec un prix inférieur à 600 : 

db.products.find({
  $or: [
    { "category": "Electronics" },
    { "price": { $lt: 600 } }
  ]
});
findOne avec $or pour trouver un produit avec une étiquette spécifique ou une note de revue supérieure à 4 : 

db.products.findOne({
  $or: [
    { "tags": "Smart" },
    { "reviews.rating": { $gt: 4 } }
  ]
});
Exemples avec delete et deleteOne
delete avec $or pour supprimer des produits dans une certaine catégorie ou avec un prix supérieur à 1000 : 

db.products.deleteMany({
  $or: [
    { "category": "Clothing" },
    { "price": { $gt: 1000 } }
  ]
});
deleteOne avec $or pour supprimer un produit spécifique ou avec une note de revue inférieure à 3 : 

db.products.deleteOne({
  $or: [
    { "name": "Television" },
    { "reviews.rating": { $lt: 3 } }
  ]
});
Exemples avec update et updateMany
update avec $or pour augmenter le prix des produits dans une certaine catégorie ou avec une note de revue inférieure à 3 : 

db.products.updateMany({
  $or: [
    { "category": "Clothing" },
    { "reviews.rating": { $lt: 3 } }
  ]
},
{
  $mul: { "price": 1.1 } // Augmente le prix de 10%
});
updateMany avec $or pour ajouter une nouvelle critique à un produit avec une certaine étiquette ou avec un prix inférieur à 500 : 

db.products.updateMany({
  $or: [
    { "tags": "4K" },
    { "price": { $lt: 500 } }
  ]
},
{
  $push: {
    "reviews": {
      "user": "User3",
      "rating": 5
    }
  }
});
Exemples avec aggregate
aggregate avec $or pour calculer la moyenne des prix des produits dans une certaine catégorie ou avec une note de revue supérieure à 4 : 

db.products.aggregate([
  {
    $match: {
      $or: [
        { "category": "Electronics" },
        { "reviews.rating": { $gt: 4 } }
      ]
    }
  },
  {
    $group: {
      _id: "$category",
      averagePrice: { $avg: "$price" }
    }
  }
]);
Supposons toujours une collection "employees" avec des documents qui ressemblent à ceci : 

{
  "_id": ObjectId("60a0c8c0f09a9b04789d13c8"),
  "name": "Bob Smith",
  "age": 35,
  "position": "Manager",
  "skills": ["Java", "SQL", "Management"],
  "projects": [
    {
      "name": "Project C",
      "duration": 10
    },
    {
      "name": "Project D",
      "duration": 12
    }
  ],
  "salary": 100000
}
Exemples avec find et findOne
find avec $or pour trouver des employés dans une certaine position ou avec une compétence spécifique : 

db.employees.find({
  $or: [
    { "position": "Manager" },
    { "skills": "Management" }
  ]
});
findOne avec $or pour trouver un employé avec un projet spécifique ou un salaire inférieur à 90000 : 

db.employees.findOne({
  $or: [
    { "projects.name": "Project C" },
    { "salary": { $lt: 90000 } }
  ]
});
Exemples avec delete et deleteOne
delete avec $or pour supprimer des employés dans une certaine position ou avec un salaire supérieur à 120000 : 

db.employees.deleteMany({
  $or: [
    { "position": "Intern" },
    { "salary": { $gt: 120000 } }
  ]
});
deleteOne avec $or pour supprimer un employé spécifique ou avec une compétence particulière : 

db.employees.deleteOne({
  $or: [
    { "name": "Bob Smith" },
    { "skills": "Java" }
  ]
});
Exemples avec update et updateMany
update avec $or pour mettre à jour le salaire des employés dans une certaine position ou avec une compétence spécifique : 

db.employees.updateMany({
  $or: [
    { "position": "Manager" },
    { "skills": "Java" }
  ]
},
{
  $mul: { "salary": 1.1 } // Augmente le salaire de 10%
});
updateMany avec $or pour ajouter une nouvelle compétence à un employé avec un projet spécifique : 

db.employees.updateMany({
  $or: [
    { "projects.name": "Project D" },
    { "position": "Developer" }
  ]
},
{
  $push: {
    "skills": "Python"
  }
});
Exemples avec aggregate
aggregate avec $or pour calculer la moyenne des salaires des employés dans une certaine position ou avec une compétence spécifique : 

db.employees.aggregate([
  {
    $match: {
      $or: [
        { "position": "Manager" },
        { "skills": "SQL" }
      ]
    }
  },
  {
    $group: {
      _id: "$position",
      averageSalary: { $avg: "$salary" }
    }
  }
]);
Supposons maintenant une collection "books" avec des documents qui ressemblent à ceci : 

{
  "_id": ObjectId("60a0c8c0f09a9b04789d13c9"),
  "title": "The Great Gatsby",
  "author": "F. Scott Fitzgerald",
  "genre": "Fiction",
  "publicationYear": 1925,
  "ratings": [
    {
      "user": "User1",
      "score": 4
    },
    {
      "user": "User2",
      "score": 5
    }
  ],
  "tags": ["Classic", "Roaring Twenties"]
}
Exemples avec find et findOne
find avec $or pour trouver des livres dans une certaine année de publication ou avec un score de notation inférieur à 4 : 

db.books.find({
  $or: [
    { "publicationYear": 1925 },
    { "ratings.score": { $lt: 4 } }
  ]
});
findOne avec $or pour trouver un livre avec un genre spécifique ou une étiquette particulière : 

db.books.findOne({
  $or: [
    { "genre": "Mystery" },
    { "tags": "Classic" }
  ]
});
Exemples avec delete et deleteOne
delete avec $or pour supprimer des livres dans un genre spécifique ou avec une étiquette particulière : 

db.books.deleteMany({
  $or: [
    { "genre": "Romance" },
    { "tags": "Adventure" }
  ]
});
deleteOne avec $or pour supprimer un livre spécifique ou avec un score de notation supérieur à 4 : 

db.books.deleteOne({
  $or: [
    { "title": "The Great Gatsby" },
    { "ratings.score": { $gt: 4 } }
  ]
});
Exemples avec update et updateMany
update avec $or pour mettre à jour le genre des livres dans une certaine année de publication ou avec une étiquette particulière : 

db.books.updateMany({
  $or: [
    { "publicationYear": 1925 },
    { "tags": "Roaring Twenties" }
  ]
},
{
  $set: { "genre": "Historical Fiction" }
});
updateMany avec $or pour ajouter une nouvelle notation à un livre avec un titre spécifique ou une étiquette particulière : 

db.books.updateMany({
  $or: [
    { "title": "To Kill a Mockingbird" },
    { "tags": "Classic" }
  ]
},
{
  $push: {
    "ratings": {
      "user": "User3",
      "score": 4
    }
  }
});
Exemples avec aggregate
aggregate avec $or pour calculer la moyenne des scores de notation des livres dans un genre spécifique ou avec une étiquette particulière : 

db.books.aggregate([
  {
    $match: {
      $or: [
        { "genre": "Fiction" },
        { "tags": "Classic" }
      ]
    }
  },
  {
    $group: {
      _id: "$genre",
      averageRating: { $avg: { $avg: "$ratings.score" } }
    }
  }
]);



{
  "_id": ObjectId("60a0c8c0f09a9b04789d13c6"),
  "customer": {
    "name": "Alice",
    "age": 28,
    "loyaltyPoints": 150
  },
  "products": [
    {
      "name": "Smartphone",
      "price": 500
    },
    {
      "name": "Headphones",
      "price": 100
    }
  ],
  "orderDate": ISODate("2023-01-01T08:00:00Z"),
  "status": "Shipped"
}
Exemples avec find et findOne
find avec $and et $or pour trouver des commandes d'un client spécifique avec un certain statut ou une date spécifique : 

db.orders.find({
  $and: [
    { "customer.name": "Alice" },
    {
      $or: [
        { "status": "Shipped" },
        { "orderDate": ISODate("2023-01-01T08:00:00Z") }
      ]
    }
  ]
});
findOne avec $or et $and pour trouver une commande avec une date spécifique, un prix total inférieur à 600, et un statut "Shipped" : 

db.orders.findOne({
  $and: [
    { "orderDate": ISODate("2023-01-01T08:00:00Z") },
    {
      $or: [
        {
          $expr: {
            $lt: [
              { $sum: "$products.price" },
              600
            ]
          }
        },
        { "status": "Shipped" }
      ]
    }
  ]
});
Exemples avec delete et deleteOne
delete avec $or et $and pour supprimer des commandes expédiées d'un client spécifique ou avec un prix total supérieur à 800 : 

db.orders.deleteMany({
  $and: [
    { "status": "Shipped" },
    { "customer.name": "Bob" },
    {
      $or: [
        {
          $expr: {
            $gt: [
              { $sum: "$products.price" },
              800
            ]
          }
        }
      ]
    }
  ]
});
deleteOne avec $or et $and pour supprimer une commande avec une date spécifique ou un produit "Headphones" : 

db.orders.deleteOne({
  $and: [
    { "orderDate": ISODate("2023-01-01T08:00:00Z") },
    {
      $or: [
        { "products.name": "Headphones" },
        { "status": "Pending" }
      ]
    }
  ]
});
Exemples avec update et updateMany
update avec $and et $or pour mettre à jour le statut des commandes expédiées d'un client spécifique ou avec un prix total supérieur à 700 : 

db.orders.updateMany({
  $and: [
    { "status": "Shipped" },
    { "customer.name": "Alice" },
    {
      $or: [
        {
          $expr: {
            $gt: [
              { $sum: "$products.price" },
              700
            ]
          }
        }
      ]
    }
  ]
},
{
  $set: { "status": "Delivered" }
});
updateMany avec $or et $and pour ajouter des points de fidélité à un client en fonction du montant total de ses commandes ou du statut "Delivered" : 

db.orders.updateMany({
  $and: [
    { "customer.name": "Alice" },
    {
      $or: [
        {
          $expr: {
            $gte: [
              { $sum: "$products.price" },
              500
            ]
          }
        },
        { "status": "Delivered" }
      ]
    }
  ]
},
{
  $inc: { "customer.loyaltyPoints": 50 }
});
Exemples avec aggregate
aggregate avec $and et $or pour calculer le montant total des commandes expédiées par catégorie de produits ou avec une date spécifique : 

db.orders.aggregate([
  {
    $match: {
      $and: [
        { "status": "Shipped" },
        {
          $or: [
            { "products.name": { $in: ["Smartphone", "Laptop"] } },
            { "orderDate": ISODate("2023-01-01T08:00:00Z") }
          ]
        }
      ]
    }
  },
  {
    $group: {
      _id: "$status",
      totalAmount: { $sum: { $sum: "$products.price" } }
    }
  }
]);
Exemples avec find et findOne
1. find avec $and et $or pour trouver des commandes d'un client spécifique avec un certain statut ou une date spécifique : 

db.orders.find({
  $and: [
    { "customer.name": "Alice" },
    {
      $or: [
        { "status": "Shipped" },
        { "orderDate": ISODate("2023-01-01T08:00:00Z") }
      ]
    }
  ]
});
$and: Combinaison logique des conditions à satisfaire.
$or: Au moins l'une des conditions à l'intérieur de cette clause doit être vraie.
"customer.name": "Alice": La commande doit appartenir à Alice.
$or: La commande doit avoir le statut "Shipped" ou avoir une date spécifique.
2. findOne avec $or et $and pour trouver une commande avec une date spécifique, un prix total inférieur à 600, et un statut "Shipped" : 

db.orders.findOne({
  $and: [
    { "orderDate": ISODate("2023-01-01T08:00:00Z") },
    {
      $or: [
        {
          $expr: {
            $lt: [
              { $sum: "$products.price" },
              600
            ]
          }
        },
        { "status": "Shipped" }
      ]
    }
  ]
});
$expr: Permet d'utiliser des expressions MongoDB, ici pour comparer le prix total.
$lt: Condition "inférieur à" pour comparer le prix total avec 600.
"orderDate": ISODate("2023-01-01T08:00:00Z"): La commande doit avoir une date spécifique.
$or: La commande doit avoir un prix total inférieur à 600 ou un statut "Shipped".
Exemples avec delete et deleteOne
1. delete avec $or et $and pour supprimer des commandes expédiées d'un client spécifique ou avec un prix total supérieur à 800 : 

db.orders.deleteMany({
  $and: [
    { "status": "Shipped" },
    { "customer.name": "Bob" },
    {
      $or: [
        {
          $expr: {
            $gt: [
              { $sum: "$products.price" },
              800
            ]
          }
        }
      ]
    }
  ]
});
$gt: Condition "supérieur à" pour comparer le prix total avec 800.
"status": "Shipped": La commande doit être expédiée.
"customer.name": "Bob": La commande doit appartenir à Bob.
$or: La commande doit avoir un prix total supérieur à 800.
2. deleteOne avec $or et $and pour supprimer une commande avec une date spécifique ou un produit "Headphones" : 

db.orders.deleteOne({
  $and: [
    { "orderDate": ISODate("2023-01-01T08:00:00Z") },
    {
      $or: [
        { "products.name": "Headphones" },
        { "status": "Pending" }
      ]
    }
  ]
});
"orderDate": ISODate("2023-01-01T08:00:00Z"): La commande doit avoir une date spécifique.
$or: La commande doit avoir un produit "Headphones" ou un statut "Pending".
Exemples avec update et updateMany
1. update avec $and et $or pour mettre à jour le statut des commandes expédiées d'un client spécifique ou avec un prix total supérieur à 700 : 

db.orders.updateMany({
  $and: [
    { "status": "Shipped" },
    { "customer.name": "Alice" },
    {
      $or: [
        {
          $expr: {
            $gt: [
              { $sum: "$products.price" },
              700
            ]
          }
        }
      ]
    }
  ]
},
{
  $set: { "status": "Delivered" }
});
$set: Met à jour le statut des commandes expédiées à "Delivered".
"status": "Shipped": La commande doit être expédiée.
"customer.name": "Alice": La commande doit appartenir à Alice.
$gt: Condition "supérieur à" pour comparer le prix total avec 700.
$or: La commande doit avoir un prix total supérieur à 700.
2. updateMany avec $or et $and pour ajouter des points de fidélité à un client en fonction du montant total de ses commandes ou du statut "Delivered" : 

db.orders.updateMany({
  $and: [
    { "customer.name": "Alice" },
    {
      $or: [
        {
          $expr: {
            $gte: [
              { $sum: "$products.price" },
              500
            ]
          }
        },
        { "status": "Delivered" }
      ]
    }
  ]
},
{
  $inc: { "customer.loyaltyPoints": 50 }
});
$inc: Incrémente les points de fidélité du client de 50.
"customer.name": "Alice": La commande doit appartenir à Alice.
$gte: Condition "supérieur ou égal à" pour comparer le prix total avec 500.
$or: La commande doit avoir un prix total supérieur ou égal à 500 ou un statut "Delivered".
Exemples avec aggregate
aggregate avec $and et $or pour calculer le montant total des commandes expédiées par catégorie de produits ou avec une date spécifique : 

db.orders.aggregate([
  {
    $match: {
      $and: [
        { "status": "Shipped" },
        {
          $or: [
            { "products.name": { $in: ["Smartphone", "Laptop"] } },
            { "orderDate": ISODate("2023-01-01T08:00:00Z") }
          ]
        }
      ]
    }
  },
  {
    $group: {
      _id: "$status",
      totalAmount: { $sum: { $sum: "$products.price" } }
    }
  }
]);
$match: Filtre les commandes expédiées avec certains produits ou une date spécifique.
$in: Vérifie si le nom du produit est dans la liste spécifiée.
$group: Groupe les commandes expédiées par statut et calcule le montant total des produits.
Ces explications devraient clarifier le rôle de chaque ligne dans les opérations MongoDB utilisant les opérateurs $and et $or. Si vous avez des questions spécifiques sur une ligne en particulier, n'hésitez pas à demander !
comment utiliser l'opérateur $not dans MongoDB avec des exemples pratiques. Revenons à la collection "orders" avec des documents similaires à ceux que nous avons utilisés précédemment : 

{
  "_id": ObjectId("60a0c8c0f09a9b04789d13c6"),
  "customer": {
    "name": "Alice",
    "age": 28,
    "loyaltyPoints": 150
  },
  "products": [
    {
      "name": "Smartphone",
      "price": 500
    },
    {
      "name": "Headphones",
      "price": 100
    }
  ],
  "orderDate": ISODate("2023-01-01T08:00:00Z"),
  "status": "Shipped"
}
Exemples avec find et findOne
1. find avec $not pour trouver des commandes qui ne sont pas expédiées : 

db.orders.find({
  "status": { $not: { $eq: "Shipped" } }
});
$not: Négation logique.
$eq: Opérateur d'égalité.
"status": { $not: { $eq: "Shipped" } }: Trouve des commandes avec un statut différent de "Shipped".
2. findOne avec $not pour trouver une commande qui n'a pas été passée par Alice : 

db.orders.findOne({
  "customer.name": { $not: { $eq: "Alice" } }
});
"customer.name": { $not: { $eq: "Alice" } }: Trouve une commande dont le nom du client n'est pas "Alice".
Exemples avec delete et deleteOne
1. delete avec $not pour supprimer des commandes qui ne sont pas expédiées ou dont le montant total est inférieur à 500 : 

db.orders.deleteMany({
  $not: {
    $or: [
      { "status": "Shipped" },
      {
        $expr: {
          $gte: [
            { $sum: "$products.price" },
            500
          ]
        }
      }
    ]
  }
});
$or: Au moins une des conditions à l'intérieur de cette clause doit être vraie.
$expr: Permet d'utiliser des expressions MongoDB.
$gte: Condition "supérieur ou égal à".
"$sum": "$products.price": Calcule le montant total des produits dans la commande.
$not: Négation de l'ensemble de conditions.
2. deleteOne avec $not pour supprimer une commande qui n'a pas été expédiée et dont le nom du produit n'est pas "Laptop" : 

db.orders.deleteOne({
  $not: {
    $and: [
      { "status": "Shipped" },
      { "products.name": "Laptop" }
    ]
  }
});
$and: Combinaison logique des conditions à satisfaire.
"status": "Shipped": La commande doit être expédiée.
"products.name": "Laptop": Le nom du produit doit être "Laptop".
$not: Négation de l'ensemble de conditions.
Exemples avec update et updateMany
1. update avec $not pour mettre à jour le statut des commandes qui ne sont pas encore expédiées : 

db.orders.updateMany(
  { "status": { $not: { $eq: "Shipped" } } },
  { $set: { "status": "Pending" } }
);
$set: Met à jour le statut des commandes non expédiées à "Pending".
"status": { $not: { $eq: "Shipped" } }: La commande ne doit pas être expédiée.
2. updateMany avec $not pour ajouter des points de fidélité à tous les clients sauf Alice : 

db.orders.updateMany(
  { "customer.name": { $not: { $eq: "Alice" } } },
  { $inc: { "customer.loyaltyPoints": 20 } }
);
$inc: Incrémente les points de fidélité du client de 20.
"customer.name": { $not: { $eq: "Alice" } }: Le nom du client ne doit pas être "Alice".
Exemples avec aggregate
aggregate avec $not pour calculer le montant total des commandes non expédiées : 

db.orders.aggregate([
  {
    $match: {
      "status": { $not: { $eq: "Shipped" } }
    }
  },
  {
    $group: {
      _id: "$status",
      totalAmount: { $sum: { $sum: "$products.price" } }
    }
  }
]);
$match: Filtre les commandes non expédiées.
$not: Négation logique.
$eq: Opérateur d'égalité.
$group: Groupe les commandes par statut et calcule le montant total des produits.
continuons avec des exemples supplémentaires d'utilisation de l'opérateur $not dans MongoDB.
Supposons une collection "employees" avec des documents qui ressemblent à ceci : 

{
  "_id": ObjectId("60a0c8c0f09a9b04789d13c8"),
  "name": "Bob Smith",
  "age": 35,
  "position": "Manager",
  "skills": ["Java", "SQL", "Management"],
  "projects": [
    {
      "name": "Project C",
      "duration": 10
    },
    {
      "name": "Project D",
      "duration": 12
    }
  ],
  "salary": 100000
}
Exemples avec find et findOne
1. find avec $not pour trouver des employés dont la position n'est pas "Developer" : 

db.employees.find({
  "position": { $not: { $eq: "Developer" } }
});
$eq: Opérateur d'égalité.
$not: Négation logique.
"position": { $not: { $eq: "Developer" } }: Trouve des employés dont la position n'est pas "Developer".
2. findOne avec $not pour trouver un employé dont l'âge n'est pas égal à 30 : 

db.employees.findOne({
  "age": { $not: { $eq: 30 } }
});
"age": { $not: { $eq: 30 } }: Trouve un employé dont l'âge n'est pas égal à 30.
Exemples avec delete et deleteOne
1. delete avec $not pour supprimer des employés dont la position n'est pas "Manager" : 

db.employees.deleteMany({
  "position": { $not: { $eq: "Manager" } }
});
"position": { $not: { $eq: "Manager" } }: Supprime des employés dont la position n'est pas "Manager".
2. deleteOne avec $not pour supprimer un employé dont le salaire n'est pas égal à 90000 : 

db.employees.deleteOne({
  "salary": { $not: { $eq: 90000 } }
});
"salary": { $not: { $eq: 90000 } }: Supprime un employé dont le salaire n'est pas égal à 90000.
Exemples avec update et updateMany
1. update avec $not pour augmenter le salaire des employés dont la position n'est pas "Intern" : 

db.employees.updateMany(
  { "position": { $not: { $eq: "Intern" } } },
  { $mul: { "salary": 1.1 } }
);
$mul: Multiplie le salaire par 1.1 (augmente le salaire de 10%).
"position": { $not: { $eq: "Intern" } }: Met à jour le salaire des employés dont la position n'est pas "Intern".
2. updateMany avec $not pour ajouter une nouvelle compétence aux employés dont le projet n'est pas "Project B" : 

db.employees.updateMany(
  { "projects.name": { $not: { $eq: "Project B" } } },
  { $push: { "skills": "Python" } }
);
$push: Ajoute une nouvelle compétence ("Python") à la liste des compétences.
"projects.name": { $not: { $eq: "Project B" } }: Ajoute la compétence uniquement aux employés dont le projet n'est pas "Project B".
Exemples avec aggregate
aggregate avec $not pour calculer la moyenne des salaires des employés dont la position n'est pas "Developer" : 

db.employees.aggregate([
  {
    $match: {
      "position": { $not: { $eq: "Developer" } }
    }
  },
  {
    $group: {
      _id: "$position",
      averageSalary: { $avg: "$salary" }
    }
  }
]);
$match: Filtre les employés dont la position n'est pas "Developer".
$not: Négation logique.
$eq: Opérateur d'égalité.
$group: Groupe les employés par position et calcule la moyenne des salaires.
comment utiliser l'opérateur $in dans MongoDB avec des exemples pratiques. Reprenons la collection "employees" avec des documents similaires à ceux que nous avons utilisés précédemment : 

{
  "_id": ObjectId("60a0c8c0f09a9b04789d13c8"),
  "name": "Bob Smith",
  "age": 35,
  "position": "Manager",
  "skills": ["Java", "SQL", "Management"],
  "projects": [
    {
      "name": "Project C",
      "duration": 10
    },
    {
      "name": "Project D",
      "duration": 12
    }
  ],
  "salary": 100000
}
Exemples avec find et findOne
1. find avec $in pour trouver des employés avec une position spécifique : 

db.employees.find({
  "position": { $in: ["Manager", "Developer"] }
});
$in: Vérifie si la valeur d'un champ est dans une liste donnée.
"position": { $in: ["Manager", "Developer"] }: Trouve des employés dont la position est "Manager" ou "Developer".
2. findOne avec $in pour trouver un employé avec une compétence spécifique : 

db.employees.findOne({
  "skills": { $in: ["Java", "Python"] }
});
"skills": { $in: ["Java", "Python"] }: Trouve un employé ayant les compétences "Java" ou "Python".
Exemples avec delete et deleteOne:
1. delete avec $in pour supprimer des employés dont la position est dans une liste spécifique : 

db.employees.deleteMany({
  "position": { $in: ["Intern", "Consultant"] }
});
"position": { $in: ["Intern", "Consultant"] }: Supprime des employés dont la position est "Intern" ou "Consultant".
2. deleteOne avec $in pour supprimer un employé avec une compétence spécifique : 

db.employees.deleteOne({
  "skills": { $in: ["Management"] }
});
"skills": { $in: ["Management"] }: Supprime un employé ayant la compétence "Management".
Exemples avec update et updateMany
1. update avec $in pour augmenter le salaire des employés dans une liste spécifique de positions : 

db.employees.updateMany(
  { "position": { $in: ["Manager", "Developer"] } },
  { $mul: { "salary": 1.1 } }
);
$mul: Multiplie le salaire par 1.1 (augmente le salaire de 10%).
"position": { $in: ["Manager", "Developer"] }: Met à jour le salaire des employés dont la position est "Manager" ou "Developer".
2. updateMany avec $in pour ajouter une nouvelle compétence à des employés dans une liste spécifique de projets : 

db.employees.updateMany(
  { "projects.name": { $in: ["Project C", "Project D"] } },
  { $push: { "skills": "MongoDB" } }
);
$push: Ajoute une nouvelle compétence ("MongoDB") à la liste des compétences.
"projects.name": { $in: ["Project C", "Project D"] }: Ajoute la compétence uniquement aux employés travaillant sur les projets "Project C" ou "Project D".
Exemples avec aggregate
aggregate avec $in pour calculer la moyenne des salaires des employés dans une liste spécifique de positions : 

db.employees.aggregate([
  {
    $match: {
      "position": { $in: ["Manager", "Developer"] }
    }
  },
  {
    $group: {
      _id: "$position",
      averageSalary: { $avg: "$salary" }
    }
  }
]);
$match: Filtre les employés dont la position est "Manager" ou "Developer".
$in: Vérifie si la valeur du champ "position" est dans la liste spécifiée.
$group: Groupe les employés par position et calcule la moyenne des salaires.
continuons avec des exemples supplémentaires d'utilisation de l'opérateur $in dans MongoDB.
Supposons une collection "products" avec des documents qui ressemblent à ceci : 

{
  "_id": ObjectId("60a0c8c0f09a9b04789d13c9"),
  "name": "Laptop",
  "category": "Electronics",
  "price": 1200,
  "features": ["High Resolution Display", "SSD", "8GB RAM"],
  "availability": true
}
Exemples avec find et findOne
1. find avec $in pour trouver des produits dans une liste spécifique de catégories : 

db.products.find({
  "category": { $in: ["Electronics", "Clothing"] }
});
$in: Vérifie si la valeur d'un champ est dans une liste donnée.
"category": { $in: ["Electronics", "Clothing"] }: Trouve des produits dont la catégorie est "Electronics" ou "Clothing".
2. findOne avec $in pour trouver un produit avec une caractéristique spécifique : 

db.products.findOne({
  "features": { $in: ["SSD"] }
});
"features": { $in: ["SSD"] }: Trouve un produit ayant la caractéristique "SSD".
Exemples avec delete et deleteOne
1. delete avec $in pour supprimer des produits dans une liste spécifique de catégories : 

db.products.deleteMany({
  "category": { $in: ["Home", "Appliances"] }
});
"category": { $in: ["Home", "Appliances"] }: Supprime des produits dont la catégorie est "Home" ou "Appliances".
2. deleteOne avec $in pour supprimer un produit avec une caractéristique spécifique : 

db.products.deleteOne({
  "features": { $in: ["High Resolution Display"] }
});
"features": { $in: ["High Resolution Display"] }: Supprime un produit ayant la caractéristique "High Resolution Display".
Exemples avec update et updateMany
1. update avec $in pour augmenter le prix des produits dans une liste spécifique de catégories : 

db.products.updateMany(
  { "category": { $in: ["Electronics", "Clothing"] } },
  { $mul: { "price": 1.1 } }
);
$mul: Multiplie le prix par 1.1 (augmente le prix de 10%).
"category": { $in: ["Electronics", "Clothing"] }: Met à jour le prix des produits dont la catégorie est "Electronics" ou "Clothing".
2. updateMany avec $in pour ajouter une nouvelle caractéristique à des produits dans une liste spécifique de catégories : 

db.products.updateMany(
  { "category": { $in: ["Electronics", "Appliances"] } },
  { $push: { "features": "Smart Technology" } }
);
$push: Ajoute une nouvelle caractéristique ("Smart Technology") à la liste des caractéristiques.
"category": { $in: ["Electronics", "Appliances"] }: Ajoute la caractéristique uniquement aux produits dont la catégorie est "Electronics" ou "Appliances".
Exemples avec aggregate
aggregate avec $in pour calculer la moyenne des prix des produits dans une liste spécifique de catégories : 

db.products.aggregate([
  {
    $match: {
      "category": { $in: ["Electronics", "Clothing"] }
    }
  },
  {
    $group: {
      _id: "$category",
      averagePrice: { $avg: "$price" }
    }
  }
]);
$match: Filtre les produits dont la catégorie est "Electronics" ou "Clothing".
$in: Vérifie si la valeur du champ "category" est dans la liste spécifiée.
$group: Groupe les produits par catégorie et calcule la moyenne des prix.
comment utiliser l'opérateur $nin dans MongoDB avec des exemples pratiques. Reprenons la collection "products" avec des documents similaires à ceux que nous avons utilisés précédemment : 

{
  "_id": ObjectId("60a0c8c0f09a9b04789d13c9"),
  "name": "Laptop",
  "category": "Electronics",
  "price": 1200,
  "features": ["High Resolution Display", "SSD", "8GB RAM"],
  "availability": true
}
Exemples avec find et findOne
1. find avec $nin pour trouver des produits dont la catégorie n'est pas dans une liste spécifique : 

db.products.find({
  "category": { $nin: ["Home", "Clothing"] }
});
$nin: Vérifie si la valeur d'un champ n'est pas dans une liste donnée.
"category": { $nin: ["Home", "Clothing"] }: Trouve des produits dont la catégorie n'est ni "Home" ni "Clothing".
2. findOne avec $nin pour trouver un produit sans une caractéristique spécifique : 

db.products.findOne({
  "features": { $nin: ["Waterproof"] }
});
"features": { $nin: ["Waterproof"] }: Trouve un produit qui n'a pas la caractéristique "Waterproof".
Exemples avec delete et deleteOne
1. delete avec $nin pour supprimer des produits dont la catégorie n'est pas dans une liste spécifique : 

db.products.deleteMany({
  "category": { $nin: ["Electronics", "Appliances"] }
});
"category": { $nin: ["Electronics", "Appliances"] }: Supprime des produits dont la catégorie n'est ni "Electronics" ni "Appliances".
2. deleteOne avec $nin pour supprimer un produit avec une caractéristique spécifique : 

db.products.deleteOne({
  "features": { $nin: ["High Resolution Display"] }
});
"features": { $nin: ["High Resolution Display"] }: Supprime un produit qui n'a pas la caractéristique "High Resolution Display".
Exemples avec update et updateMany
1. update avec $nin pour baisser le prix des produits dont la catégorie n'est pas dans une liste spécifique : 

db.products.updateMany(
  { "category": { $nin: ["Electronics", "Clothing"] } },
  { $mul: { "price": 0.9 } }
);
$mul: Multiplie le prix par 0.9 (baisse le prix de 10%).
"category": { $nin: ["Electronics", "Clothing"] }: Met à jour le prix des produits dont la catégorie n'est ni "Electronics" ni "Clothing".
2. updateMany avec $nin pour supprimer une caractéristique spécifique de produits dont la catégorie n'est pas dans une liste spécifique : 

db.products.updateMany(
  { "category": { $nin: ["Electronics", "Appliances"] } },
  { $pull: { "features": "Smart Technology" } }
);
$pull: Supprime une caractéristique spécifique ("Smart Technology") de la liste des caractéristiques.
"category": { $nin: ["Electronics", "Appliances"] }: Supprime la caractéristique uniquement des produits dont la catégorie n'est ni "Electronics" ni "Appliances".
Exemples avec aggregate
aggregate avec $nin pour calculer la moyenne des prix des produits dont la catégorie n'est pas dans une liste spécifique : 

db.products.aggregate([
  {
    $match: {
      "category": { $nin: ["Electronics", "Clothing"] }
    }
  },
  {
    $group: {
      _id: "$category",
      averagePrice: { $avg: "$price" }
    }
  }
]);
$match: Filtre les produits dont la catégorie n'est ni "Electronics" ni "Clothing".
$nin: Vérifie si la valeur du champ "category" n'est pas dans la liste spécifiée.
$group: Groupe les produits par catégorie et calcule la moyenne des prix.
continuons avec des exemples supplémentaires d'utilisation de l'opérateur $nin dans MongoDB.
Supposons une collection "employees" avec des documents qui ressemblent à ceci : 

{
  "_id": ObjectId("60a0c8c0f09a9b04789d13c8"),
  "name": "Bob Smith",
  "age": 35,
  "position": "Manager",
  "skills": ["Java", "SQL", "Management"],
  "projects": [
    {
      "name": "Project C",
      "duration": 10
    },
    {
      "name": "Project D",
      "duration": 12
    }
  ],
  "salary": 100000
}
Exemples avec find et findOne
1. find avec $nin pour trouver des employés dont la position n'est pas dans une liste spécifique : 

db.employees.find({
  "position": { $nin: ["Intern", "Consultant"] }
});
$nin: Vérifie si la valeur d'un champ n'est pas dans une liste donnée.
"position": { $nin: ["Intern", "Consultant"] }: Trouve des employés dont la position n'est ni "Intern" ni "Consultant".
2. findOne avec $nin pour trouver un employé sans une compétence spécifique : 

db.employees.findOne({
  "skills": { $nin: ["Python"] }
});
"skills": { $nin: ["Python"] }: Trouve un employé qui n'a pas la compétence "Python".
Exemples avec delete et deleteOne
1. delete avec $nin pour supprimer des employés dont la position n'est pas dans une liste spécifique : 

db.employees.deleteMany({
  "position": { $nin: ["Manager", "Developer"] }
});
"position": { $nin: ["Manager", "Developer"] }: Supprime des employés dont la position n'est ni "Manager" ni "Developer".
2. deleteOne avec $nin pour supprimer un employé sans une compétence spécifique : 

db.employees.deleteOne({
  "skills": { $nin: ["Management"] }
});
"skills": { $nin: ["Management"] }: Supprime un employé qui n'a pas la compétence "Management".
Exemples avec update et updateMany
1. update avec $nin pour augmenter le salaire des employés dont la position n'est pas dans une liste spécifique : 

db.employees.updateMany(
  { "position": { $nin: ["Intern", "Consultant"] } },
  { $mul: { "salary": 1.1 } }
);
$mul: Multiplie le salaire par 1.1 (augmente le salaire de 10%).
"position": { $nin: ["Intern", "Consultant"] }: Met à jour le salaire des employés dont la position n'est ni "Intern" ni "Consultant".
2. updateMany avec $nin pour supprimer une compétence spécifique des employés dont la position n'est pas dans une liste spécifique : 

db.employees.updateMany(
  { "position": { $nin: ["Manager", "Developer"] } },
  { $pull: { "skills": "Java" } }
);
$pull: Supprime une compétence spécifique ("Java") de la liste des compétences.
"position": { $nin: ["Manager", "Developer"] }: Supprime la compétence uniquement des employés dont la position n'est ni "Manager" ni "Developer".
Exemples avec aggregate
aggregate avec $nin pour calculer la moyenne des salaires des employés dont la position n'est pas dans une liste spécifique : 

db.employees.aggregate([
  {
    $match: {
      "position": { $nin: ["Intern", "Consultant"] }
    }
  },
  {
    $group: {
      _id: "$position",
      averageSalary: { $avg: "$salary" }
    }
  }
]);
$match: Filtre les employés dont la position n'est ni "Intern" ni "Consultant".
$nin: Vérifie si la valeur du champ "position" n'est pas dans la liste spécifiée.
$group: Groupe les employés par position et calcule la moyenne des salaires.
comment utiliser les opérateurs $or, $and, $in, $nin, et $not en MongoDB avec des exemples. Nous allons utiliser la collection "employees" avec des documents similaires à ceux que nous avons utilisés précédemment : 

{
  "_id": ObjectId("60a0c8c0f09a9b04789d13c8"),
  "name": "Bob Smith",
  "age": 35,
  "position": "Manager",
  "skills": ["Java", "SQL", "Management"],
  "projects": [
    {
      "name": "Project C",
      "duration": 10
    },
    {
      "name": "Project D",
      "duration": 12
    }
  ],
  "salary": 100000
}
Exemples avec find et findOne
1. find avec $or pour trouver des employés dont la position est "Manager" ou qui ont la compétence "Python" : 

db.employees.find({
  $or: [
    { "position": "Manager" },
    { "skills": "Python" }
  ]
});
$or: Au moins une des conditions à l'intérieur de cette clause doit être vraie.
{ "position": "Manager" }: Trouve des employés dont la position est "Manager".
{ "skills": "Python" }: Trouve des employés ayant la compétence "Python".
2. findOne avec $and pour trouver un employé qui est "Manager" et a la compétence "Java" : 

db.employees.findOne({
  $and: [
    { "position": "Manager" },
    { "skills": "Java" }
  ]
});
$and: Toutes les conditions à l'intérieur de cette clause doivent être vraies.
{ "position": "Manager" }: Trouve un employé dont la position est "Manager".
{ "skills": "Java" }: Trouve un employé ayant la compétence "Java".
3. find avec $in pour trouver des employés dont la position est "Manager" ou "Developer" : 

db.employees.find({
  "position": { $in: ["Manager", "Developer"] }
});
"position": { $in: ["Manager", "Developer"] }: Trouve des employés dont la position est "Manager" ou "Developer".
4. find avec $nin pour trouver des employés dont la position n'est ni "Intern" ni "Consultant" : 

db.employees.find({
  "position": { $nin: ["Intern", "Consultant"] }
});
"position": { $nin: ["Intern", "Consultant"] }: Trouve des employés dont la position n'est ni "Intern" ni "Consultant".
5. find avec $not pour trouver des employés qui n'ont pas la compétence "Python" : 

db.employees.find({
  "skills": { $not: { $eq: "Python" } }
});
$not: Négation logique.
$eq: Opérateur d'égalité.
"skills": { $not: { $eq: "Python" } }: Trouve des employés qui n'ont pas la compétence "Python".
Exemples avec delete et deleteOne
1. delete avec $or pour supprimer des employés qui sont "Manager" ou qui ont la compétence "Python" : 

db.employees.deleteMany({
  $or: [
    { "position": "Manager" },
    { "skills": "Python" }
  ]
});
$or: Au moins une des conditions à l'intérieur de cette clause doit être vraie.
{ "position": "Manager" }: Supprime des employés dont la position est "Manager".
{ "skills": "Python" }: Supprime des employés ayant la compétence "Python".
2. deleteOne avec $and pour supprimer un employé qui est "Manager" et a la compétence "Java" : 

db.employees.deleteOne({
  $and: [
    { "position": "Manager" },
    { "skills": "Java" }
  ]
});
$and: Toutes les conditions à l'intérieur de cette clause doivent être vraies.
{ "position": "Manager" }: Supprime un employé dont la position est "Manager".
{ "skills": "Java" }: Supprime un employé ayant la compétence "Java".
3. delete avec $in pour supprimer des employés dont la position est "Manager" ou "Developer" : 

db.employees.deleteMany({
  "position": { $in: ["Manager", "Developer"] }
});