MongoDB Academy · Pelajaran

Mengisi Data Dengan Skrip Node.js

Pelajar akan menulis skrip pengisian Node.js yang membaca fail JSON dan memasukkan dokumen secara pukal ke dalam MongoDB untuk pembangunan setempat.

Pelajaran 4 daripada 413 langkah

Mengisi Data Dengan Skrip Node.js ialah pelajaran MongoDB Academy percuma di CoddyKit. Ini ialah pelajaran 4 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran MongoDB Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus MongoDB Academy merangkumi sejumlah 4 pelajaran.

Mengapa Menulis Skrip Seed?

Skrip seed ialah program Node.js yang mengisi pangkalan data MongoDB dengan data awal atau data ujian. Tidak seperti mongoimport, skrip seed boleh menjana data dinamik (ID, hubungan dan cap masa), memasukkan data secara bersyarat yang belum wujud, dan menggunakan logik perniagaan semasa proses seed—contohnya, mencincang kata laluan atau mengira medan terbitan. Skrip seed ialah asas penyediaan persekitaran pembangunan setempat.

Menyediakan MongoDB Client

Skrip seed bersambung ke MongoDB menggunakan pemacu Node.js rasmi mongodb. Simpan URI sambungan dalam pemboleh ubah persekitaran atau fail .env—jangan sekali-kali menulis kelayakan secara terus dalam kod. Panggil client.connect() pada permulaan, jalankan semua operasi seed, dan panggil client.close() dalam blok finally untuk memastikan skrip keluar dengan bersih walaupun berlaku ralat.

const { MongoClient, ObjectId } = require('mongodb');

const URI = process.env.MONGO_URI || 'mongodb://localhost:27017';
const DB_NAME = 'myapp';

async function seed() {
  const client = new MongoClient(URI);
  try {
    await client.connect();
    console.log('Connected to MongoDB');
    const db = client.db(DB_NAME);
    await seedUsers(db);
    await seedProducts(db);
    console.log('Seeding complete!');
  } finally {
    await client.close();
  }
}

seed().catch(console.error);

Memasukkan Dokumen dengan bulkWrite

Gunakan collection.bulkWrite() bersama ordered: false untuk sisipan pukal yang cekap. Tidak seperti beberapa panggilan insertOne, bulkWrite menghantar semua operasi kepada pelayan dalam satu perjalanan rangkaian. Tetapkan ordered: false supaya ralat kunci pendua pada dokumen tertentu tidak menghentikan keseluruhan kelompok—berguna apabila menjalankan semula skrip seed yang menggunakan ID deterministik.

async function seedUsers(db) {
  const users = [
    { _id: new ObjectId('aaa000000000000000000001'), name: 'Alice', email: 'alice@example.com', role: 'admin' },
    { _id: new ObjectId('aaa000000000000000000002'), name: 'Bob',   email: 'bob@example.com',   role: 'user'  },
    { _id: new ObjectId('aaa000000000000000000003'), name: 'Carol', email: 'carol@example.com', role: 'user'  }
  ];

  const ops = users.map(u => ({ insertOne: { document: u } }));
  const result = await db.collection('users').bulkWrite(ops, { ordered: false });
  console.log('Users inserted:', result.insertedCount);
}

Seed Idempoten dengan deleteMany

Jadikan skrip seed Anda idempoten—selamat dijalankan berkali-kali—dengan mengosongkan collection sasaran sebelum memasukkan data. Panggil deleteMany({}) (atau drop()) pada permulaan setiap fungsi seed. Ini memastikan pangkalan data bermula daripada keadaan bersih yang diketahui setiap kali skrip dijalankan, yang penting untuk pembangunan setempat apabila Anda memerlukan data yang boleh dihasilkan semula tanpa pendua.

async function seedProducts(db) {
  const col = db.collection('products');

  // Clear existing data first — idempotent
  await col.deleteMany({});
  console.log('Cleared products collection');

  const products = generateProducts(50); // generate 50 sample products
  await col.insertMany(products);
  console.log('Inserted', products.length, 'products');
}

Menjana Data Palsu yang Realistik

Untuk seed pembangunan, jana data yang kelihatan realistik secara terprogram menggunakan pustaka pembantu seperti @faker-js/faker atau dengan membina data secara manual. Menjana data dalam skrip (bukannya memuatkan fail JSON statik) membolehkan Anda mengubah jumlah data dengan mudah—jana 10 dokumen untuk ujian unit, 10,000 untuk ujian beban—hanya dengan mengubah satu parameter.

function generateProducts(count) {
  const categories = ['electronics', 'clothing', 'tools', 'books'];
  return Array.from({ length: count }, (_, i) => ({
    _id: new ObjectId(),
    sku: 'PROD-' + String(i + 1).padStart(4, '0'),
    name: 'Product ' + (i + 1),
    price: parseFloat((Math.random() * 100 + 1).toFixed(2)),
    category: categories[i % categories.length],
    rating: parseFloat((Math.random() * 2 + 3).toFixed(1)), // 3.0 - 5.0
    isActive: true,
    createdAt: new Date(Date.now() - i * 86400000) // staggered dates
  }));
}

Mengisi Hubungan antara Collection

Apabila mengisi collection yang berkaitan, cipta dokumen induk terlebih dahulu dan gunakan nilai _id dokumen tersebut semasa mencipta dokumen anak. Menggunakan ObjectIds deterministik (yang dibina daripada rentetan heks tetap) membolehkan Anda merujuk dokumen induk tertentu dengan boleh dipercayai dalam setiap pelaksanaan tanpa perlu mencarinya selepas pemasukan.

const USER_ID_ALICE = new ObjectId('aaa000000000000000000001');
const USER_ID_BOB   = new ObjectId('aaa000000000000000000002');

async function seedOrders(db) {
  await db.collection('orders').deleteMany({});
  const orders = [
    { userId: USER_ID_ALICE, total: 49.99,  status: 'delivered', createdAt: new Date() },
    { userId: USER_ID_BOB,   total: 120.00, status: 'pending',   createdAt: new Date() }
  ];
  await db.collection('orders').insertMany(orders);
  console.log('Orders seeded');
}

Membaca Data Seed daripada Fail JSON

Untuk data seed kompleks yang lebih mudah diselenggara dalam format JSON (katalog produk, senarai negara, jadual konfigurasi), baca fail JSON dengan fs.readFileSync dan hantarkan tatasusunan yang telah dihuraikan terus kepada insertMany. Gabungkan pendekatan ini dengan pendekatan deleteMany yang idempoten supaya skrip boleh dijalankan semula dengan selamat selepas fail JSON diedit.

const fs  = require('fs');
const path = require('path');

async function seedFromFile(db, collectionName, filePath) {
  const raw  = fs.readFileSync(path.resolve(filePath), 'utf-8');
  const docs = JSON.parse(raw);

  const col = db.collection(collectionName);
  await col.deleteMany({});
  await col.insertMany(docs);
  console.log('Seeded', docs.length, 'documents into', collectionName);
}

// Usage
await seedFromFile(db, 'countries', './seed-data/countries.json');

Mencipta Indeks selepas Seed

Skrip seed hendaklah mencipta indeks yang sama seperti yang digunakan dalam pengeluaran. Panggil collection.createIndex() (atau createIndexes()) pada akhir setiap fungsi seed, atau dalam langkah ensureIndexes khusus. Mencipta indeks selepas pemasukan pukal lebih pantas berbanding mengekalkannya semasa pemasukan—MongoDB membina B-tree daripada data yang telah diisih dalam satu laluan.

async function ensureIndexes(db) {
  // Products: fast category lookups and rating sorts
  await db.collection('products').createIndex({ category: 1, rating: -1 });
  await db.collection('products').createIndex({ sku: 1 }, { unique: true });

  // Orders: fast user-based queries
  await db.collection('orders').createIndex({ userId: 1, createdAt: -1 });

  console.log('Indexes created');
}

Menjalankan Skrip Seed

Jalankan skrip seed daripada baris perintah dengan node seed.js atau tambahkannya pada bahagian skrip package.json Anda. Hantarkan URI khusus persekitaran melalui pemboleh ubah persekitaran supaya skrip yang sama berfungsi untuk persekitaran setempat, CI dan pementasan tanpa pengubahsuaian. Jangan sekali-kali menjalankan skrip seed yang memanggil deleteMany terhadap URI pengeluaran.

// package.json scripts
// {
//   "scripts": {
//     "seed": "node scripts/seed.js",
//     "seed:test": "MONGO_URI=mongodb://localhost:27017 node scripts/seed.js"
//   }
// }

// Run with:
// npm run seed
// or
// MONGO_URI='mongodb://localhost:27017' node scripts/seed.js

Menggunakan Skrip Seed dalam Saluran Paip CI

Dalam saluran paip CI, jalankan skrip seed sebagai sebahagian daripada langkah persediaan ujian sebelum melaksanakan ujian integrasi atau ujian hujung ke hujung. Mulakan bekas Docker MongoDB (atau gunakan mongodb-memory-server), jalankan skrip seed untuk mengisi data ujian, jalankan ujian, kemudian hapuskan bekas tersebut. Ini memberikan keadaan pangkalan data yang bersih dan boleh dihasilkan semula pada setiap pelaksanaan CI.

# GitHub Actions step example
# - name: Start MongoDB
#   run: docker run -d -p 27017:27017 mongo:7

# - name: Seed test data
#   run: node scripts/seed.js
#   env:
#     MONGO_URI: mongodb://localhost:27017

# - name: Run integration tests
#   run: npm test
#   env:
#     MONGO_URI: mongodb://localhost:27017

Mengendalikan Ralat Seed dengan Baik

Bungkus fungsi seed Anda dalam blok try/catch supaya kegagalan dalam satu bahagian tidak menyebabkan pangkalan data berada dalam keadaan separa diisi tanpa mesej ralat yang jelas. Catat ralat tersebut, hentikan langkah seed yang selebihnya dan keluar dengan kod bukan sifar supaya saluran paip CI dapat mengesan kegagalan itu. Seed separa selalunya lebih buruk daripada tiada seed kerana menghasilkan keputusan ujian yang mengelirukan.

async function seed() {
  const client = new MongoClient(process.env.MONGO_URI);
  try {
    await client.connect();
    const db = client.db('myapp');
    await seedUsers(db);
    await seedProducts(db);
    await seedOrders(db);
    await ensureIndexes(db);
    console.log('All seed steps completed successfully');
    process.exit(0);
  } catch (err) {
    console.error('Seed failed:', err.message);
    process.exit(1);
  } finally {
    await client.close();
  }
}

Semakan Pantas

Uji pemahaman Anda tentang konsep MongoDB & pangkalan data NoSQL daripada pelajaran ini.

Jawab dalam pelajaran interaktif

Ringkasan Pelajaran

Dalam pelajaran ini Anda telah mempelajari bahawa: skrip seed menggunakan pemacu Node.js untuk memasukkan, mengosongkan dan menjana semula data ujian secara terprogram, ObjectIds deterministik menjadikan hubungan antara collection boleh dihasilkan semula dalam setiap pelaksanaan, dan memanggil deleteMany pada permulaan setiap fungsi seed menjadikan skrip idempoten serta selamat untuk dijalankan semula. Kursus Mengimport dan Mengeksport Data ini selesai—seterusnya kita beralih kepada Asas Indeks untuk prestasi pertanyaan bertaraf pengeluaran.

Percuma untuk bermula

Pelajari JavaScript dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 30
Pelajaran: 120

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Mengisi Data Dengan Skrip Node.js” percuma?

Ya — teks penuh “Mengisi Data Dengan Skrip Node.js” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus MongoDB Academy, tingkat taraf kepada CoddyKit PRO. Kursus MongoDB Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Mengisi Data Dengan Skrip Node.js”?

Pelajar akan menulis skrip pengisian Node.js yang membaca fail JSON dan memasukkan dokumen secara pukal ke dalam MongoDB untuk pembangunan setempat. Anda berlatih MongoDB Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan MongoDB Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran MongoDB Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 4 daripada 4.

Berapa lamakah pelajaran “Mengisi Data Dengan Skrip Node.js” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran MongoDB Academy ini?

Ya. Setiap pelajaran MongoDB Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

mongoimport: Memuatkan Fail JSON dan CSV
mongoexport: Mengeksport Koleksi ke Fail
mongodump dan mongorestore untuk Sandaran Penuh
Mengisi Data Dengan Skrip Node.js

← Kembali ke MongoDB Academy