Grundlagen der mongosh-Shell
Verwenden Sie mongosh, um Datenbanken zu wechseln, Collections aufzulisten und interaktiv Ihre ersten Dokumentabfragen auszuführen.
Grundlagen der mongosh-Shell ist eine kostenlose MongoDB Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des MongoDB Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der MongoDB Academy-Kurs umfasst insgesamt 4 Lektionen.
Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.
What Is mongosh?
mongosh is MongoDB's official shell, built on Node.js — so you can use modern JavaScript right inside it. It's the standard way to connect from the command line.
# Install mongosh on macOS
brew install mongosh
# Connect to a local MongoDB instance
mongosh
# Connect to an Atlas cluster
mongosh 'mongodb+srv://user:pass@cluster0.abc.mongodb.net/myapp'
# Connect with explicit host and port
mongosh --host localhost --port 27017Navigating Databases and Collections
A few commands help you get around: show dbs lists databases, use switches one, and show collections lists what's inside. The db variable is always your current database.
// Navigate in mongosh
show dbs
// admin 0.000GB
// myapp 0.008GB
use myapp
// switched to db myapp
db
// myapp
show collections
// users
// ordersYour First Insert
Adding your first document is one line: insertOne. It returns the new _id, and a quick findOne confirms it saved. The code walks through both steps.
// Insert one document
db.users.insertOne({
name: 'Alice',
email: 'alice@example.com',
age: 28,
createdAt: new Date()
});
// { acknowledged: true, insertedId: ObjectId('64a2f3b1...') }
// Verify it was stored
db.users.findOne();
// { _id: ObjectId('64a2f3b1...'), name: 'Alice', ... }Basic find() Queries
find returns all matching documents; pass a filter to narrow it, or use findOne for exactly one. An empty filter returns everything. The code shows a few.
// Find all documents
db.users.find({});
// Find with an equality filter
db.users.find({ name: 'Alice' });
// findOne by _id
db.users.findOne({ _id: ObjectId('64a2f3b1...') });
// Find with multiple conditions (implicit AND)
db.users.find({ age: 28, active: true });
// Type 'it' in shell to get next 20 resultsCounting and Limiting Results
A few helpers control how much you get back: countDocuments, plus limit and skip on a query. Together, limit and skip are the basis of pagination. The code shows them.
// Count active users
db.users.countDocuments({ active: true });
// 842
// Get first 5 users
db.users.find({}).limit(5);
// Skip first 10, get next 5 (page 3 of 5-per-page)
db.users.find({}).skip(10).limit(5);
// Fast approximate total
db.users.estimatedDocumentCount();
// 4823Sorting Query Results
Chain sort to order results — 1 for ascending, -1 for descending. You can even sort by several fields at once as tiebreakers. The code shows a few sorts.
// Sort by age descending (oldest first)
db.users.find({}).sort({ age: -1 });
// Sort by last name then first name
db.users.find({}).sort({ lastName: 1, firstName: 1 });
// Most recently created first
db.users.find({}).sort({ createdAt: -1 }).limit(10);
// Combined: find active users, sort by age, limit to 5
db.users.find({ active: true }).sort({ age: 1 }).limit(5);Projections: Selecting Fields
A projection picks which fields come back — 1 to include, 0 to exclude. It trims bandwidth and memory when you don't need every field. The code shows examples.
// Include only name and email (exclude everything else)
db.users.find({}, { name: 1, email: 1 });
// { _id: ObjectId('...'), name: 'Alice', email: 'alice@...' }
// Exclude _id too
db.users.find({}, { name: 1, email: 1, _id: 0 });
// { name: 'Alice', email: 'alice@...' }
// Exclude sensitive fields
db.users.find({}, { passwordHash: 0, ssn: 0 });Pretty Printing and Shell Helpers
mongosh pretty-prints results for you automatically. Handy helpers include toArray, forEach, distinct, and explain to peek at how a query runs. The code shows them.
// Get all distinct cities from user addresses
db.users.distinct('address.city');
// ['Chicago', 'London', 'Tokyo', ...]
// Iterate with forEach
db.users.find({ active: true }).forEach(user => {
print(user.name + ' - ' + user.email);
});
// Check if query uses an index
db.users.find({ email: 'alice@test.com' }).explain('executionStats');Quick Update and Delete Commands
You'll cover full CRUD later, but the essentials are updateOne, deleteOne, and deleteMany. Always use $set in updates, or you'll replace the whole document!
// Update a specific field (CORRECT: use $set)
db.users.updateOne(
{ email: 'alice@example.com' },
{ $set: { age: 29, updatedAt: new Date() } }
);
// Delete one document
db.users.deleteOne({ email: 'alice@example.com' });
// WARNING: This REPLACES the entire document (no $set):
// db.users.updateOne({ email: '...' }, { age: 29 });
// Now the document has ONLY { _id, age: 29 } !!!Shell Variables and Scripting
Since mongosh is real JavaScript, you can use variables, loops, and scripts to automate tasks — far more powerful than a plain SQL CLI. The code shows a loop.
// Variable-driven query
const targetCity = 'Chicago';
const users = db.users.find({ 'address.city': targetCity }).toArray();
print('Users in ' + targetCity + ': ' + users.length);
// For loop to seed test data
for (let i = 1; i <= 10; i++) {
db.products.insertOne({ name: 'Product ' + i, price: i * 10 });
}
// Run from CLI without entering the shell:
// mongosh mydb --eval "db.users.countDocuments({})"Connecting to Atlas From the Shell
To reach Atlas, grab the connection string from its UI — it uses mongodb+srv, which finds your cluster via DNS. Store it in an env var, not your shell history.
# Store URI in environment variable (never hard-code credentials)
export MONGODB_URI='mongodb+srv://alice:s3cr3t@cluster0.abc.mongodb.net'
# Connect from shell
mongosh $MONGODB_URI
# Switch to your app database
use myapp
# Verify connection
db.runCommand({ ping: 1 })
# { ok: 1 }Quick Check
Test your understanding of MongoDB & NoSQL Databases concepts from this lesson.
Lesson Recap
You learned mongosh is a JavaScript shell, that projections pick fields, and that you chain sort, limit, and skip to shape results. Next: inserting documents.
Häufig gestellte Fragen
Ist die Lektion „Grundlagen der mongosh-Shell“ kostenlos?
Ja — der vollständige Text von „Grundlagen der mongosh-Shell“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des MongoDB Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der MongoDB Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Grundlagen der mongosh-Shell“?
Verwenden Sie mongosh, um Datenbanken zu wechseln, Collections aufzulisten und interaktiv Ihre ersten Dokumentabfragen auszuführen. Du übst MongoDB Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um MongoDB Academy zu starten?
Keine Vorkenntnisse erforderlich. MongoDB Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.
Wie lange dauert die Lektion „Grundlagen der mongosh-Shell“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser MongoDB Academy-Lektion Code schreiben und ausführen?
Ja. Jede MongoDB Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Was ist ein BSON-Dokument?
- Collections und SQL-Tabellen im Vergleich
- Datenbanken, Collections und Namespaces
- Grundlagen der mongosh-Shell