Fundamentos do shell mongosh
Use mongosh para alternar entre bancos de dados, listar coleções e executar suas primeiras consultas a documentos de forma interativa.
Fundamentos do shell mongosh é uma aula grátis de MongoDB Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de MongoDB Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de MongoDB Academy inclui 4 aulas no total.
Partes desta aula ainda não foram traduzidas e aparecem em inglês.
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.
Perguntas Frequentes
A aula “Fundamentos do shell mongosh” é grátis?
Sim — o texto completo de “Fundamentos do shell mongosh” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de MongoDB Academy, atualize para CoddyKit PRO. O curso de MongoDB Academy inclui 4 aulas no total.
O que vou aprender em “Fundamentos do shell mongosh”?
Use mongosh para alternar entre bancos de dados, listar coleções e executar suas primeiras consultas a documentos de forma interativa. Você pratica MongoDB Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar MongoDB Academy?
Nenhuma experiência prévia é necessária. MongoDB Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.
Quanto tempo leva a aula “Fundamentos do shell mongosh”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de MongoDB Academy?
Sim. Cada aula de MongoDB Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- O que é um documento BSON?
- Coleções versus tabelas SQL
- Bancos de dados, coleções e espaços de nomes
- Fundamentos do shell mongosh