$push et $addToSet : construire des tableaux dans les groupes
Les apprenants rassembleront dans des tableaux les valeurs issues de documents regroupés et les dédupliqueront avec $addToSet.
$push et $addToSet : construire des tableaux dans les groupes est une leçon MongoDB Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage MongoDB Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours MongoDB Academy comprend 4 leçons au total.
Rassembler des valeurs dans des tableaux
Lors du regroupement de documents, vous pouvez parfois vouloir rassembler les valeurs individuelles d'un champ dans un tableau plutôt que calculer un agrégat numérique. MongoDB fournit deux accumulateurs pour cela : $push et $addToSet. Tous deux créent un résultat sous forme de tableau à partir de documents regroupés, mais ils diffèrent dans leur gestion des valeurs en double. Ces accumulateurs sont essentiels pour produire des résultats dénormalisés ou regroupés.
$push : rassembler toutes les valeurs
$push ajoute la valeur de l'expression indiquée à un tableau pour chaque document du groupe. Il conserve les doublons : si plusieurs documents partagent la même valeur, celle-ci apparaîtra plusieurs fois dans le tableau obtenu. L'ordre des éléments du tableau correspond à l'ordre dans lequel les documents ont été traités, lequel peut varier si vous n'effectuez pas de tri avant le regroupement.
db.orders.aggregate([
{
$group: {
_id: '$customerId',
// Collect all product IDs ordered by this customer
orderedProducts: { $push: '$productId' },
orderDates: { $push: '$createdAt' }
}
}
])$addToSet : rassembler les valeurs uniques
$addToSet fonctionne comme $push, mais il élimine les doublons : chaque valeur unique n'est ajoutée au tableau qu'une seule fois. Le tableau obtenu ne contient aucun élément répété, comme un ensemble mathématique. L'ordre des éléments dans le résultat n'est pas garanti avec $addToSet ; vous ne devez donc pas vous y fier. Utilisez-le lorsque vous avez besoin d'une liste distincte de valeurs par groupe.
db.logs.aggregate([
{
$group: {
_id: {
year: { $year: '$timestamp' },
month: { $month: '$timestamp' }
},
// Unique users who logged in this month
uniqueUsers: { $addToSet: '$userId' },
// Every event type including duplicates
allEvents: { $push: '$eventType' }
}
}
])Ajouter des objets intégrés
Vous pouvez utiliser $push pour ajouter des sous-documents ou des objets calculés entiers, et pas uniquement des valeurs scalaires. En construisant une expression objet, vous pouvez rassembler plusieurs champs de chaque document dans un élément de tableau structuré. C'est utile pour créer des enregistrements récapitulatifs qui intègrent les détails de chaque document ayant contribué au résultat.
db.orders.aggregate([
{
$group: {
_id: '$customerId',
orderHistory: {
$push: {
orderId: '$_id',
amount: '$amount',
status: '$status',
date: '$createdAt'
}
}
}
}
])Combiner $push avec $sort
Comme l'ordre des éléments d'un tableau créé avec $push dépend de l'ordre de traitement des documents, vous devez ajouter une étape $sort avant $group lorsque l'ordre du tableau rassemblé est important. Par exemple, pour rassembler les commandes dans l'ordre chronologique au sein de chaque groupe de clients, triez d'abord par date. Notez que le tri avant $group empêche MongoDB d'utiliser de nombreuses optimisations liées aux index ; évaluez donc le compromis en matière de performances.
db.orders.aggregate([
// Sort by date first so $push produces ordered arrays
{ $sort: { createdAt: 1 } },
{
$group: {
_id: '$customerId',
ordersInChronologicalOrder: {
$push: {
orderId: '$_id',
date: '$createdAt',
amount: '$amount'
}
}
}
}
])Limites de taille des documents et croissance des tableaux
Les documents MongoDB ont une limite de taille de 16 Mo. Lorsque vous utilisez $push dans une étape $group, le document obtenu peut dépasser cette limite si un groupe contient beaucoup de documents ou si chaque valeur ajoutée est volumineuse. Il s'agit d'une erreur à l'exécution, et non d'une erreur de schéma. Pour l'éviter, filtrez les données avant le regroupement, ne projetez dans $push que les champs nécessaires ou utilisez $limit avec $sort pour n'ajouter que les N premiers éléments.
// Safe pattern: project only needed fields before pushing
db.events.aggregate([
{ $match: { year: 2024 } },
{
$project: {
userId: 1,
eventType: 1 // exclude large 'payload' field
}
},
{
$group: {
_id: '$userId',
events: { $push: '$eventType' }
}
}
])Utiliser $addToSet pour rassembler des étiquettes uniques
Un cas d'utilisation classique de $addToSet consiste à agréger les étiquettes ou catégories uniques des documents d'un groupe. Par exemple, vous pouvez trouver toutes les étiquettes de compétences uniques parmi les offres d'emploi de chaque entreprise, ou toutes les catégories de produits uniques achetées par chaque client. La déduplication s'effectue entièrement côté serveur, sans nécessiter de filtrage au niveau de l'application.
db.jobPostings.aggregate([
{
$group: {
_id: '$companyId',
uniqueSkills: { $addToSet: '$requiredSkills' },
totalPostings: { $sum: 1 }
}
},
{ $sort: { totalPostings: -1 } }
])Vérifier la taille d'un tableau avec $size dans $project
Après avoir rassemblé des valeurs avec $push ou $addToSet, vous souhaitez souvent savoir combien d'éléments se trouvent dans le tableau. Utilisez $size dans une étape $project ou $addFields suivante pour calculer la longueur du tableau. Vous pouvez également filtrer les groupes selon la taille du tableau en utilisant $match avec $expr et $size.
db.orders.aggregate([
{
$group: {
_id: '$customerId',
products: { $addToSet: '$productId' }
}
},
{
$addFields: {
uniqueProductCount: { $size: '$products' }
}
},
// Only customers who bought 3 or more unique products
{ $match: { uniqueProductCount: { $gte: 3 } } }
])Désimbriquer après un regroupement
Vous devez parfois inverser un $push : prendre le tableau regroupé et le développer à nouveau en documents individuels pour poursuivre le traitement. L'étape $unwind fait exactement cela. Un modèle courant consiste à effectuer : $group avec $push pour consolider → $project pour transformer → $unwind pour développer → un autre $group ou $match pour affiner les résultats.
db.orders.aggregate([
{ $group: { _id: '$customerId', products: { $push: '$productId' } } },
// Expand back into per-product documents
{ $unwind: '$products' },
// Now further filter or group by product
{
$group: {
_id: '$products',
customerCount: { $sum: 1 }
}
},
{ $sort: { customerCount: -1 } }
])Modèle concret : récapitulatif de l'activité d'un utilisateur
Un modèle courant en production consiste à créer un document de récapitulatif de l'activité d'un utilisateur en regroupant les événements de journalisation. En utilisant $push et $addToSet ensemble, vous pouvez générer un document contenant tous les horodatages des événements (tableau trié avec $push), toutes les pages visitées uniques (dédupliquées avec $addToSet) et le nombre total d'événements, le tout en un seul passage d'agrégation.
db.pageViews.aggregate([
{ $sort: { timestamp: 1 } },
{
$group: {
_id: '$userId',
visitTimestamps: { $push: '$timestamp' },
uniquePages: { $addToSet: '$page' },
totalVisits: { $sum: 1 }
}
},
{
$addFields: {
uniquePageCount: { $size: '$uniquePages' }
}
}
])Comparaison entre $push et $addToSet
Pour choisir entre $push et $addToSet, demandez-vous : les doublons sont-ils importants ? Utilisez $push lorsque vous avez besoin de toutes les valeurs, y compris les répétitions (par exemple, un journal d’événements ou un historique d’achats). Utilisez $addToSet lorsque vous ne voulez que des valeurs distinctes (par exemple, des étiquettes uniques ou les pages visitées distinctes). N’oubliez pas que $addToSet ne garantit aucun ordre particulier pour les éléments du tableau obtenu, tandis que $push conserve l’ordre d’insertion relatif aux données d’entrée du pipeline.
// $push — all values, order preserved
{ $push: '$tag' } // ['mongodb', 'nosql', 'mongodb', 'database']
// $addToSet — unique values only, order not guaranteed
{ $addToSet: '$tag' } // ['mongodb', 'database', 'nosql']Vérification rapide
Testez votre compréhension des concepts de MongoDB et des bases de données NoSQL présentés dans cette leçon.
Récapitulatif de la leçon
Dans cette leçon, vous avez appris que $push rassemble toutes les valeurs, y compris les doublons, dans un tableau, que $addToSet ne rassemble que les valeurs uniques, sans garantir leur ordre, et que les deux peuvent ajouter des sous-documents complexes et doivent respecter la limite de 16 Mo par document. Nous allons maintenant découvrir $first, $last ainsi que les accumulateurs $top/$bottom, qui permettent de sélectionner des documents individuels pour chaque groupe.
Apprends JavaScript avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 30
- Leçons
- 120
Questions Fréquemment Posées
La leçon « $push et $addToSet : construire des tableaux dans les groupes » est-elle gratuite ?
Oui — le texte complet de « $push et $addToSet : construire des tableaux dans les groupes » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours MongoDB Academy, passe à CoddyKit PRO. Le cours MongoDB Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « $push et $addToSet : construire des tableaux dans les groupes » ?
Les apprenants rassembleront dans des tableaux les valeurs issues de documents regroupés et les dédupliqueront avec $addToSet. Tu pratiques MongoDB Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer MongoDB Academy ?
Aucune expérience préalable n'est requise. MongoDB Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.
Combien de temps prend la leçon « $push et $addToSet : construire des tableaux dans les groupes » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon MongoDB Academy ?
Oui. Chaque leçon MongoDB Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- $sum, $avg, $min, $max : agrégation numérique
- $push et $addToSet : construire des tableaux dans les groupes
- Accumulateurs $first, $last et $top/$bottom
- Fonctions de fenêtre avec $setWindowFields