Wie man MongoDB Arrays aktualisiert

Einführung

In diesem Lab lernen Sie, wie Sie Arrays innerhalb von MongoDB-Dokumenten manipulieren. Sie üben das Hinzufügen, Entfernen und Aktualisieren von Array-Elementen mithilfe der leistungsstarken Update-Operatoren von MongoDB. Das Lab bietet Schritt-für-Schritt-Anleitungen und praktische Beispiele, die Ihnen helfen, die Array-Verwaltung in Ihren MongoDB-Datenbanken zu meistern.

Sie beginnen damit, Elemente mithilfe des $push-Operators zu einem Array hinzuzufügen. Als Nächstes lernen Sie, Elemente mithilfe der Operatoren $pull und $pullAll zu entfernen. Sie werden auch untersuchen, wie Sie bestimmte Elemente innerhalb eines Arrays ändern und wie Sie $addToSet verwenden, um sicherzustellen, dass ein Array nur eindeutige Elemente enthält. Abschließend lernen Sie, wie Sie vorhandene Duplikate aus einem Array mithilfe einer Aggregations-Pipeline entfernen.

Elemente mit `$push` zu einem Array hinzufügen

In diesem Schritt lernen Sie, wie Sie mit dem $push-Operator neue Elemente zu einem Array in einem MongoDB-Dokument hinzufügen. Dieser Operator hängt einen angegebenen Wert an ein Array an.

Öffnen Sie zunächst die MongoDB-Shell, um mit Ihrer Datenbank zu interagieren. Alle Datenbankoperationen in diesem Lab werden innerhalb dieser Shell durchgeführt.

mongosh

Wechseln Sie nach dem Öffnen der Shell zur Datenbank arraylab. Diese Datenbank wurde während des Einrichtungsprozesses für Sie erstellt.

use arraylab

Das Setup-Skript hat auch eine students-Collection mit einem Dokument erstellt. Suchen wir dieses Dokument, um seinen aktuellen Zustand zu sehen.

db.students.findOne({ name: "Alice Johnson" })

Sie sollten die folgende Ausgabe sehen, die zeigt, dass Alice in zwei Kursen eingeschrieben ist:

{
  _id: ObjectId('...'),
  name: 'Alice Johnson',
  courses: [ 'Mathematics', 'Computer Science' ]
}

Fügen wir nun mit dem $push-Operator einen neuen Kurs, "Data Structures", zu Alices courses-Array hinzu.

db.students.updateOne(
    { name: "Alice Johnson" },
    { $push: { courses: "Data Structures" } }
)

Die Methode updateOne sucht ein Dokument, das dem Filter { name: "Alice Johnson" } entspricht, und wendet das Update { $push: { courses: "Data Structures" } } an. Der $push-Operator hängt den neuen Kurs an das courses-Array an.

Sie können auch mehrere Elemente gleichzeitig hinzufügen, indem Sie $push mit dem $each-Modifikator kombinieren. Fügen wir "Physics" und "Chemistry" zum Array hinzu.

db.students.updateOne(
    { name: "Alice Johnson" },
    { $push: { courses: { $each: ["Physics", "Chemistry"] } } }
)

Um zu bestätigen, dass alle neuen Kurse hinzugefügt wurden, führen Sie den findOne-Befehl erneut aus.

db.students.findOne({ name: "Alice Johnson" })

Das aktualisierte Dokument enthält nun alle fünf Kurse:

{
  _id: ObjectId('...'),
  name: 'Alice Johnson',
  courses: [
    'Mathematics',
    'Computer Science',
    'Data Structures',
    'Physics',
    'Chemistry'
  ]
}

Elemente aus einem Array entfernen

In diesem Schritt lernen Sie, wie Sie Elemente aus einem Array mit den Operatoren $pull und $pullAll entfernen. $pull entfernt alle Vorkommen eines angegebenen Werts, während $pullAll alle Vorkommen mehrerer angegebener Werte entfernt.

Sie sollten sich noch in der mongosh-Shell aus dem vorherigen Schritt befinden. Beginnen wir damit, den Kurs "Physics" aus Alices Liste mit dem $pull-Operator zu entfernen.

db.students.updateOne(
    { name: "Alice Johnson" },
    { $pull: { courses: "Physics" } }
)

Dieser Befehl sucht das Dokument für "Alice Johnson" und entfernt den String "Physics" aus ihrem courses-Array.

Als Nächstes entfernen wir mehrere Kurse gleichzeitig. Der $pullAll-Operator ist dafür perfekt geeignet. Wir werden "Mathematics" und "Chemistry" entfernen.

db.students.updateOne(
    { name: "Alice Johnson" },
    { $pullAll: { courses: ["Mathematics", "Chemistry"] } }
)

Nun überprüfen wir den endgültigen Zustand des Dokuments, um zu sehen, welche Kurse noch vorhanden sind.

db.students.findOne({ name: "Alice Johnson" })

Die Ausgabe zeigt, dass "Physics", "Mathematics" und "Chemistry" entfernt wurden, sodass nur noch zwei Kurse übrig bleiben.

{
  _id: ObjectId('...'),
  name: 'Alice Johnson',
  courses: [ 'Computer Science', 'Data Structures' ]
}

Spezifische Elemente in einem Array aktualisieren

In diesem Schritt lernen Sie, wie Sie spezifische Elemente innerhalb eines Arrays ändern. Dies ist nützlich, wenn Ihr Array Objekte enthält und Sie ein Feld in einem dieser Objekte aktualisieren müssen.

Fügen wir zunächst ein neues Studentendokument ein. Das courses-Array dieses Dokuments enthält Objekte mit jeweils einem name und einer grade.

db.students.insertOne({
    name: "Bob Smith",
    courses: [
        { name: "Mathematics", grade: "B" },
        { name: "Computer Science", grade: "A" },
        { name: "Physics", grade: "C" }
    ]
})

Angenommen, wir möchten Bobs Note in "Computer Science" von "A" auf "A+" ändern. Wir können den positionellen Operator $ verwenden. Dieser Operator fungiert als Platzhalter für das erste Element, das der Abfragebedingung entspricht.

db.students.updateOne(
    { name: "Bob Smith", "courses.name": "Computer Science" },
    { $set: { "courses.$.grade": "A+" } }
)

In diesem Befehl identifiziert die Abfrage { "courses.name": "Computer Science" } das richtige Array-Element. Das Update { $set: { "courses.$.grade": "A+" } } verwendet dann $ , um sich auf dieses Element zu beziehen und sein grade-Feld zu aktualisieren.

Überprüfen wir die Änderung.

db.students.findOne({ name: "Bob Smith" })

Die Ausgabe zeigt die aktualisierte Note:

{
  _id: ObjectId('...'),
  name: 'Bob Smith',
  courses: [
    { name: 'Mathematics', grade: 'B' },
    { name: 'Computer Science', grade: 'A+' },
    { name: 'Physics', grade: 'C' }
  ]
}

Sie können auch alle Elemente in einem Array auf einmal mit dem positionellen Operator $[ ] aktualisieren. Fügen wir allen Kursen von Bob ein semester-Feld hinzu.

db.students.updateOne(
    { name: "Bob Smith" },
    { $set: { "courses.$[].semester": "Fall 2023" } }
)

Überprüfen Sie das endgültige Dokument, um das Ergebnis zu sehen.

db.students.findOne({ name: "Bob Smith" })

Alle Kursobjekte im Array haben nun das Feld semester.

{
  _id: ObjectId('...'),
  name: 'Bob Smith',
  courses: [
    { name: 'Mathematics', grade: 'B', semester: 'Fall 2023' },
    { name: 'Computer Science', grade: 'A+', semester: 'Fall 2023' },
    { name: 'Physics', grade: 'C', semester: 'Fall 2023' }
  ]
}

Eindeutige Elemente mit `$addToSet` sicherstellen

In diesem Schritt lernen Sie, den Operator $addToSet zu verwenden. Dieser Operator fügt ein Element zu einem Array hinzu, nur wenn es noch nicht im Array vorhanden ist, und verhindert so doppelte Einträge.

Fügen wir zunächst einen neuen Studenten mit einem Array von Fähigkeiten hinzu.

db.students.insertOne({
    name: "Emma Wilson",
    skills: ["Python", "JavaScript"]
})

Versuchen wir nun, "Python" erneut mit $addToSet hinzuzufügen. Da "Python" bereits im Array vorhanden ist, wird diese Operation das Dokument nicht ändern.

db.students.updateOne(
    { name: "Emma Wilson" },
    { $addToSet: { skills: "Python" } }
)

Überprüfen wir das Dokument zur Bestätigung.

db.students.findOne({ name: "Emma Wilson" })

Sie werden sehen, dass das skills-Array unverändert geblieben ist, da "Python" bereits vorhanden war.

{
  _id: ObjectId('...'),
  name: 'Emma Wilson',
  skills: [ 'Python', 'JavaScript' ]
}

Ähnlich wie $push kann $addToSet mit dem Modifikator $each kombiniert werden, um mehrere Werte hinzuzufügen. Es werden nur die Werte hinzugefügt, die noch nicht im Array vorhanden sind.

db.students.updateOne(
    { name: "Emma Wilson" },
    { $addToSet: {
        skills: {
            $each: ["React", "Node.js", "Python", "TypeScript"]
        }
    } }
)

Überprüfen wir das endgültige Dokument.

db.students.findOne({ name: "Emma Wilson" })

Die neuen, eindeutigen Fähigkeiten wurden hinzugefügt, während das doppelte "Python" ignoriert wurde.

{
  _id: ObjectId('...'),
  name: 'Emma Wilson',
  skills: [ 'Python', 'JavaScript', 'React', 'Node.js', 'TypeScript' ]
}

Vorhandene Duplikate aus einem Array entfernen

Während $addToSet das Hinzufügen neuer Duplikate verhindert, gibt es manchmal Dokumente, bei denen ein Array bereits doppelte Werte enthält. In diesem Schritt lernen Sie, wie Sie vorhandene Duplikate mithilfe einer Aggregations-Pipeline entfernen.

Zuerst fügen wir ein Dokument mit einem skills-Array ein, das Duplikate enthält.

db.students.insertOne({
    name: "Michael Chen",
    skills: ["Python", "JavaScript", "Python", "React", "JavaScript", "Node.js"]
})

Um diese Duplikate zu entfernen, können wir eine Aggregations-Pipeline mit der $merge-Stage verwenden. Diese Pipeline liest das Dokument, erstellt ein neues Array mit eindeutigen Elementen und aktualisiert dann das ursprüngliche Dokument.

Zuerst müssen wir einen Index für das name-Feld erstellen, um sicherzustellen, dass die $merge-Operation korrekt funktioniert:

db.students.createIndex({ name: 1 }, { unique: true })

Führen Sie nun den folgenden Aggregationsbefehl aus:

db.students.aggregate([
    { $match: { name: "Michael Chen" } },
    { $project: {
        name: 1,
        skills: { $setUnion: "$skills" }
    } },
    { $merge: { into: "students", on: "name", whenMatched: "replace" } }
])

Lassen Sie uns diese Pipeline aufschlüsseln:

$match: Diese Stage filtert die Dokumente, um nur das für "Michael Chen" zu verarbeiten.
$project: Diese Stage formt das Dokument neu. Wir behalten das name-Feld bei und ersetzen das skills-Array durch die Ausgabe von $setUnion: "$skills". Der $setUnion-Operator nimmt ein Array entgegen und gibt ein neues Array zurück, das nur die eindeutigen Elemente enthält.
$merge: Diese Stage schreibt die Ergebnisse der Pipeline zurück in die students-Collection. Sie findet das zu aktualisierende Dokument anhand des name-Feldes (on: "name") und ersetzt das gesamte Dokument durch das neue aus der Pipeline (whenMatched: "replace"). Der von uns erstellte Index gewährleistet eine effiziente Übereinstimmung und Aktualisierung.

Lassen Sie uns nun überprüfen, ob die Duplikate entfernt wurden.

db.students.findOne({ name: "Michael Chen" })

Die Ausgabe zeigt das skills-Array mit nur eindeutigen Elementen. Die Reihenfolge der Elemente kann variieren.

{
  _id: ObjectId('...'),
  name: 'Michael Chen',
  skills: [ 'JavaScript', 'Node.js', 'Python', 'React' ]
}

Zusammenfassung

In diesem Lab haben Sie mehrere wesentliche Techniken zur Verwaltung von Arrays in MongoDB kennengelernt. Sie haben das Hinzufügen von Elementen mit $push, deren Entfernung mit $pull und $pullAll sowie die Aktualisierung spezifischer Elemente mithilfe des Positionsoperators $ geübt. Sie haben auch untersucht, wie Sie eindeutige Elemente in einem Array mit $addToSet beibehalten und wie Sie vorhandene Duplikate mithilfe einer Aggregationspipeline mit $setUnion und $merge bereinigen. Diese Fähigkeiten sind grundlegend für die Erstellung dynamischer und robuster Anwendungen mit MongoDB.

MongoDB Arrays aktualisieren