Fondamenti della shell mongosh
Utilizzerà mongosh per cambiare database, elencare le collection ed eseguire interattivamente le prime query sui documenti.
Fondamenti della shell mongosh è una lezione MongoDB Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento MongoDB Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso MongoDB Academy include 4 lezioni in totale.
Parti di questa lezione non sono ancora state tradotte e vengono mostrate in inglese.
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.
Impara JavaScript con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 30
- Lezioni
- 120
Domande Frequenti
La lezione «Fondamenti della shell mongosh» è gratuita?
Sì — il testo completo di «Fondamenti della shell mongosh» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso MongoDB Academy, passa a CoddyKit PRO. Il corso MongoDB Academy include 4 lezioni in totale.
Cosa imparerò in «Fondamenti della shell mongosh»?
Utilizzerà mongosh per cambiare database, elencare le collection ed eseguire interattivamente le prime query sui documenti. Eserciti MongoDB Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare MongoDB Academy?
Non è richiesta alcuna esperienza precedente. MongoDB Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.
Quanto tempo richiede la lezione «Fondamenti della shell mongosh»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione MongoDB Academy?
Sì. Ogni lezione MongoDB Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Che cos'è un documento BSON?
- Collection e tabelle SQL a confronto
- Database, collection e namespace
- Fondamenti della shell mongosh