0Pricing
MongoDB Academy · Aula

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 27017

Navigating 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
// orders

Your 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 results

Counting 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();
// 4823

Sorting 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

  1. O que é um documento BSON?
  2. Coleções versus tabelas SQL
  3. Bancos de dados, coleções e espaços de nomes
  4. Fundamentos do shell mongosh
← Voltar para MongoDB Academy