Cara membuat koleksi di mongodb tanpa dokumen apa pun menggunakan luwak di node js

Staf perpustakaan akan menggunakan situs web Perpustakaan Daerah untuk menyimpan informasi tentang buku dan peminjam, sementara anggota perpustakaan akan menggunakannya untuk menelusuri dan mencari buku, mencari tahu apakah ada salinan yang tersedia, dan kemudian memesan atau meminjamnya. Untuk menyimpan dan mengambil informasi secara efisien, kami akan menyimpannya dalam database

Aplikasi ekspres dapat menggunakan banyak database berbeda, dan ada beberapa pendekatan yang dapat Anda gunakan untuk melakukan operasi Buat, Baca, Perbarui, dan Hapus (CRUD). Tutorial ini memberikan ikhtisar singkat tentang beberapa opsi yang tersedia dan kemudian menunjukkan secara detail mekanisme tertentu yang dipilih

Aplikasi Express dapat menggunakan database apa pun yang didukung oleh Node (Express sendiri tidak menentukan perilaku/persyaratan tambahan khusus untuk manajemen database). Ada banyak opsi populer, termasuk PostgreSQL, MySQL, Redis, SQLite, dan MongoDB

Saat memilih database, Anda harus mempertimbangkan hal-hal seperti waktu-ke-produktivitas/kurva pembelajaran, kinerja, kemudahan replikasi/pencadangan, biaya, dukungan komunitas, dll. Meskipun tidak ada satu pun database "terbaik", hampir semua solusi populer seharusnya lebih dari cukup untuk situs berukuran kecil hingga menengah seperti Perpustakaan Lokal kami

Untuk informasi selengkapnya tentang opsi, lihat Integrasi basis data (Express docs)

Ada dua pendekatan umum untuk berinteraksi dengan database

• Menggunakan bahasa kueri asli basis data (mis. g. SQL)
• Menggunakan Object Data Model ("ODM") atau Object Relational Model ("ORM"). ODM/ORM merepresentasikan data situs web sebagai objek JavaScript, yang kemudian dipetakan ke database yang mendasarinya. Beberapa ORM terikat ke database tertentu, sementara yang lain menyediakan backend database-agnostik

Performa terbaik dapat diperoleh dengan menggunakan SQL, atau bahasa kueri apa pun yang didukung oleh database. ODM seringkali lebih lambat karena mereka menggunakan kode terjemahan untuk memetakan antara objek dan format basis data, yang mungkin tidak menggunakan kueri basis data yang paling efisien (ini terutama berlaku jika ODM mendukung backend basis data yang berbeda, dan harus membuat kompromi yang lebih besar dalam hal basis data apa

Manfaat menggunakan ORM adalah pemrogram dapat terus berpikir dalam kerangka objek JavaScript daripada semantik basis data — ini terutama berlaku jika Anda perlu bekerja dengan basis data yang berbeda (baik di situs web yang sama atau berbeda). Mereka juga menyediakan tempat yang jelas untuk melakukan validasi data

Catatan. Menggunakan ODM/ORM sering menghasilkan biaya yang lebih rendah untuk pengembangan dan pemeliharaan. Kecuali jika Anda sangat terbiasa dengan bahasa kueri asli atau kinerja adalah yang terpenting, Anda harus mempertimbangkan untuk menggunakan ODM

Ada banyak solusi ODM/ORM yang tersedia di situs pengelola paket npm (lihat tag odm dan orm untuk subset. )

Beberapa solusi yang populer pada saat penulisan adalah

• Luwak. Mongoose adalah alat pemodelan objek MongoDB yang dirancang untuk bekerja di lingkungan asinkron
• Garis air. ORM yang diekstraksi dari kerangka web Sails berbasis Express. Ini menyediakan API seragam untuk mengakses berbagai database yang berbeda, termasuk Redis, MySQL, LDAP, MongoDB, dan Postgres
• Rak buku. Menampilkan antarmuka panggilan balik berbasis janji dan tradisional, menyediakan dukungan transaksi, pemuatan relasi bersemangat/bersarang, asosiasi polimorfik, dan dukungan untuk relasi satu-ke-satu, satu-ke-banyak, dan banyak-ke-banyak. Bekerja dengan PostgreSQL, MySQL, dan SQLite3
• Keberatan. Membuatnya semudah mungkin untuk menggunakan kekuatan penuh SQL dan mesin basis data yang mendasarinya (mendukung SQLite3, Postgres, dan MySQL)
• Sequelize adalah ORM berbasis janji untuk Node. js dan io. js. Ini mendukung dialek PostgreSQL, MySQL, MariaDB, SQLite, dan MSSQL dan menampilkan dukungan transaksi yang solid, relasi, replikasi baca, dan lainnya
• Node ORM2 adalah Object Relationship Manager untuk NodeJS. Ini mendukung MySQL, SQLite, dan Progress, membantu bekerja dengan database menggunakan pendekatan berorientasi objek
• GrafikQL. Terutama bahasa kueri untuk API yang tenang, GraphQL sangat populer, dan memiliki fitur yang tersedia untuk membaca data dari database

Sebagai aturan umum, Anda harus mempertimbangkan fitur yang disediakan dan "aktivitas komunitas" (pengunduhan, kontribusi, laporan bug, kualitas dokumentasi, dll. ) saat memilih solusi. Pada saat penulisan, Mongoose sejauh ini merupakan ODM paling populer, dan merupakan pilihan yang masuk akal jika Anda menggunakan MongoDB untuk database Anda

Untuk contoh Perpustakaan Lokal (dan sisa topik ini) kita akan menggunakan ODM Mongoose untuk mengakses data perpustakaan kita. Mongoose bertindak sebagai ujung depan MongoDB, database NoSQL open source yang menggunakan model data berorientasi dokumen. "Kumpulan" "dokumen" dalam database MongoDB analog dengan "tabel" "baris" dalam database relasional

Kombinasi ODM dan basis data ini sangat populer di komunitas Node, sebagian karena penyimpanan dokumen dan sistem kueri sangat mirip dengan JSON, dan karenanya akrab bagi pengembang JavaScript

Catatan. Anda tidak perlu mengetahui MongoDB untuk menggunakan Mongoose, meskipun bagian dari dokumentasi Mongoose lebih mudah digunakan dan dipahami jika Anda sudah terbiasa dengan MongoDB

Bagian selanjutnya dari tutorial ini menunjukkan cara mendefinisikan dan mengakses skema dan model Mongoose untuk contoh situs web LocalLibrary

Sebelum Anda masuk dan mulai membuat kode model, ada baiknya meluangkan beberapa menit untuk memikirkan tentang data apa yang perlu kita simpan dan hubungan antara objek yang berbeda.

Kami tahu bahwa kami perlu menyimpan informasi tentang buku (judul, ringkasan, penulis, genre, ISBN) dan bahwa kami mungkin memiliki banyak salinan yang tersedia (dengan id unik global, status ketersediaan, dll. ). Kami mungkin perlu menyimpan lebih banyak informasi tentang penulis daripada hanya nama mereka, dan mungkin ada beberapa penulis dengan nama yang sama atau serupa. Kami ingin dapat mengurutkan informasi berdasarkan judul buku, penulis, genre, dan kategori

Saat mendesain model Anda, masuk akal untuk memiliki model terpisah untuk setiap "objek" (sekelompok informasi terkait). Dalam hal ini beberapa kandidat yang jelas untuk model ini adalah buku, contoh buku, dan penulis

Anda mungkin juga ingin menggunakan model untuk mewakili opsi daftar pilihan (mis. g. seperti daftar drop-down pilihan), alih-alih melakukan hard-coding pilihan ke dalam situs web itu sendiri — ini disarankan jika semua opsi tidak diketahui sebelumnya atau mungkin berubah. Contoh yang baik adalah genre (mis. g. fantasi, fiksi ilmiah, dll. )

Setelah kami memutuskan model dan bidang kami, kami perlu memikirkan hubungan di antara mereka

Dengan pemikiran tersebut, diagram asosiasi UML di bawah menunjukkan model yang akan kita definisikan dalam kasus ini (sebagai kotak). Seperti dibahas di atas, kami telah membuat model untuk buku (detail umum buku), instance buku (status salinan fisik tertentu dari buku yang tersedia di sistem), dan penulis. Kami juga telah memutuskan untuk memiliki model untuk genre tersebut sehingga nilai dapat dibuat secara dinamis. Kami telah memutuskan untuk tidak memiliki model untuk

// Require Mongoose
const mongoose = require("mongoose");

// Define a schema
const Schema = mongoose.Schema;

const SomeModelSchema = new Schema({
  a_string: String,
  a_date: Date,
});

Diagram juga menunjukkan hubungan antar model, termasuk multiplisitasnya. Perkalian adalah angka pada diagram yang menunjukkan angka (maksimum dan minimum) dari masing-masing model yang mungkin ada dalam hubungan tersebut. Misalnya, garis penghubung antar kotak menunjukkan bahwa

// Require Mongoose
const mongoose = require("mongoose");

// Define a schema
const Schema = mongoose.Schema;

const SomeModelSchema = new Schema({
  a_string: String,
  a_date: Date,
});

// Require Mongoose
const mongoose = require("mongoose");

// Define a schema
const Schema = mongoose.Schema;

const SomeModelSchema = new Schema({
  a_string: String,
  a_date: Date,
});

// Require Mongoose
const mongoose = require("mongoose");

// Define a schema
const Schema = mongoose.Schema;

const SomeModelSchema = new Schema({
  a_string: String,
  a_date: Date,
});

// Require Mongoose
const mongoose = require("mongoose");

// Define a schema
const Schema = mongoose.Schema;

const SomeModelSchema = new Schema({
  a_string: String,
  a_date: Date,
});

// Require Mongoose
const mongoose = require("mongoose");

// Define a schema
const Schema = mongoose.Schema;

const SomeModelSchema = new Schema({
  a_string: String,
  a_date: Date,
});

// Require Mongoose
const mongoose = require("mongoose");

// Define a schema
const Schema = mongoose.Schema;

const SomeModelSchema = new Schema({
  a_string: String,
  a_date: Date,
});

// Require Mongoose
const mongoose = require("mongoose");

// Define a schema
const Schema = mongoose.Schema;

const SomeModelSchema = new Schema({
  a_string: String,
  a_date: Date,
});

Catatan. Seperti yang dibahas di bawah ini, seringkali lebih baik memiliki bidang yang menentukan hubungan antara dokumen/model hanya dalam satu model (Anda masih dapat menemukan hubungan terbalik dengan mencari

// Define schema
const Schema = mongoose.Schema;

const SomeModelSchema = new Schema({
  a_string: String,
  a_date: Date,
});

// Compile model from schema
const SomeModel = mongoose.model("SomeModel", SomeModelSchema);

// Require Mongoose
const mongoose = require("mongoose");

// Define a schema
const Schema = mongoose.Schema;

const SomeModelSchema = new Schema({
  a_string: String,
  a_date: Date,
});

// Require Mongoose
const mongoose = require("mongoose");

// Define a schema
const Schema = mongoose.Schema;

const SomeModelSchema = new Schema({
  a_string: String,
  a_date: Date,
});

// Require Mongoose
const mongoose = require("mongoose");

// Define a schema
const Schema = mongoose.Schema;

const SomeModelSchema = new Schema({
  a_string: String,
  a_date: Date,
});

// Define schema
const Schema = mongoose.Schema;

const SomeModelSchema = new Schema({
  a_string: String,
  a_date: Date,
});

// Compile model from schema
const SomeModel = mongoose.model("SomeModel", SomeModelSchema);

// Require Mongoose
const mongoose = require("mongoose");

// Define a schema
const Schema = mongoose.Schema;

const SomeModelSchema = new Schema({
  a_string: String,
  a_date: Date,
});

const schema = new Schema({
  name: String,
  binary: Buffer,
  living: Boolean,
  updated: { type: Date, default: Date.now() },
  age: { type: Number, min: 18, max: 65, required: true },
  mixed: Schema.Types.Mixed,
  _someId: Schema.Types.ObjectId,
  array: [],
  ofString: [String], // You can also have an array of each of the other types too.
  nested: { stuff: { type: String, lowercase: true, trim: true } },
});

const schema = new Schema({
  name: String,
  binary: Buffer,
  living: Boolean,
  updated: { type: Date, default: Date.now() },
  age: { type: Number, min: 18, max: 65, required: true },
  mixed: Schema.Types.Mixed,
  _someId: Schema.Types.ObjectId,
  array: [],
  ofString: [String], // You can also have an array of each of the other types too.
  nested: { stuff: { type: String, lowercase: true, trim: true } },
});

Catatan. Bagian selanjutnya memberikan primer dasar yang menjelaskan bagaimana model didefinisikan dan digunakan. Saat Anda membacanya, pertimbangkan bagaimana kita akan membuat masing-masing model dalam diagram di atas

Bagian ini memberikan ikhtisar tentang cara menyambungkan Mongoose ke database MongoDB, cara menentukan skema dan model, dan cara membuat kueri dasar

Catatan. Primer ini sangat dipengaruhi oleh mulai cepat Mongoose di npm dan dokumentasi resmi

Mongoose diinstal di proyek Anda (package. json) seperti ketergantungan lainnya — menggunakan npm. Untuk menginstalnya, gunakan perintah berikut di dalam folder proyek Anda

npm install mongoose

Menginstal Mongoose menambahkan semua dependensinya, termasuk driver database MongoDB, tetapi tidak menginstal MongoDB sendiri. Jika Anda ingin menginstal server MongoDB maka Anda dapat mendownload installer dari sini untuk berbagai sistem operasi dan menginstalnya secara lokal. Anda juga dapat menggunakan instans MongoDB berbasis cloud

Catatan. Untuk tutorial ini, kita akan menggunakan database berbasis cloud MongoDB Atlas sebagai tingkat layanan gratis untuk menyediakan database. Ini cocok untuk pengembangan dan masuk akal untuk tutorial karena membuat sistem operasi "instalasi" independen (database-as-a-service juga merupakan salah satu pendekatan yang mungkin Anda gunakan untuk database produksi Anda)

Mongoose membutuhkan koneksi ke database MongoDB. Anda dapat

const schema = new Schema({
  name: String,
  binary: Buffer,
  living: Boolean,
  updated: { type: Date, default: Date.now() },
  age: { type: Number, min: 18, max: 65, required: true },
  mixed: Schema.Types.Mixed,
  _someId: Schema.Types.ObjectId,
  array: [],
  ofString: [String], // You can also have an array of each of the other types too.
  nested: { stuff: { type: String, lowercase: true, trim: true } },
});

const schema = new Schema({
  name: String,
  binary: Buffer,
  living: Boolean,
  updated: { type: Date, default: Date.now() },
  age: { type: Number, min: 18, max: 65, required: true },
  mixed: Schema.Types.Mixed,
  _someId: Schema.Types.ObjectId,
  array: [],
  ofString: [String], // You can also have an array of each of the other types too.
  nested: { stuff: { type: String, lowercase: true, trim: true } },
});

// Import the mongoose module
const mongoose = require("mongoose");

// Set `strictQuery: false` to globally opt into filtering by properties that aren't in the schema
// Included because it removes preparatory warnings for Mongoose 7.
// See: https://mongoosejs.com/docs/migrating_to_6.html#strictquery-is-removed-and-replaced-by-strict
mongoose.set('strictQuery', false);

// Define the database URL to connect to.
const mongoDB = "mongodb://127.0.0.1/my_database";

// Wait for database to connect, logging an error if there is a problem 
main().catch(err => console.log(err));
async function main() {
  await mongoose.connect(mongoDB);
}

Anda bisa mendapatkan objek

const schema = new Schema({
  name: String,
  binary: Buffer,
  living: Boolean,
  updated: { type: Date, default: Date.now() },
  age: { type: Number, min: 18, max: 65, required: true },
  mixed: Schema.Types.Mixed,
  _someId: Schema.Types.ObjectId,
  array: [],
  ofString: [String], // You can also have an array of each of the other types too.
  nested: { stuff: { type: String, lowercase: true, trim: true } },
});

const schema = new Schema({
  name: String,
  binary: Buffer,
  living: Boolean,
  updated: { type: Date, default: Date.now() },
  age: { type: Number, min: 18, max: 65, required: true },
  mixed: Schema.Types.Mixed,
  _someId: Schema.Types.ObjectId,
  array: [],
  ofString: [String], // You can also have an array of each of the other types too.
  nested: { stuff: { type: String, lowercase: true, trim: true } },
});

const schema = new Schema({
  name: String,
  binary: Buffer,
  living: Boolean,
  updated: { type: Date, default: Date.now() },
  age: { type: Number, min: 18, max: 65, required: true },
  mixed: Schema.Types.Mixed,
  _someId: Schema.Types.ObjectId,
  array: [],
  ofString: [String], // You can also have an array of each of the other types too.
  nested: { stuff: { type: String, lowercase: true, trim: true } },
});

const schema = new Schema({
  name: String,
  binary: Buffer,
  living: Boolean,
  updated: { type: Date, default: Date.now() },
  age: { type: Number, min: 18, max: 65, required: true },
  mixed: Schema.Types.Mixed,
  _someId: Schema.Types.ObjectId,
  array: [],
  ofString: [String], // You can also have an array of each of the other types too.
  nested: { stuff: { type: String, lowercase: true, trim: true } },
});

const schema = new Schema({
  name: String,
  binary: Buffer,
  living: Boolean,
  updated: { type: Date, default: Date.now() },
  age: { type: Number, min: 18, max: 65, required: true },
  mixed: Schema.Types.Mixed,
  _someId: Schema.Types.ObjectId,
  array: [],
  ofString: [String], // You can also have an array of each of the other types too.
  nested: { stuff: { type: String, lowercase: true, trim: true } },
});

const schema = new Schema({
  name: String,
  binary: Buffer,
  living: Boolean,
  updated: { type: Date, default: Date.now() },
  age: { type: Number, min: 18, max: 65, required: true },
  mixed: Schema.Types.Mixed,
  _someId: Schema.Types.ObjectId,
  array: [],
  ofString: [String], // You can also have an array of each of the other types too.
  nested: { stuff: { type: String, lowercase: true, trim: true } },
});

Model ditentukan menggunakan antarmuka

const breakfastSchema = new Schema({
  eggs: {
    type: Number,
    min: [6, "Too few eggs"],
    max: 12,
    required: [true, "Why no eggs?"],
  },
  drink: {
    type: String,
    enum: ["Coffee", "Tea", "Water"],
  },
});

Skema kemudian "dikompilasi" menjadi model menggunakan metode

const breakfastSchema = new Schema({
  eggs: {
    type: Number,
    min: [6, "Too few eggs"],
    max: 12,
    required: [true, "Why no eggs?"],
  },
  drink: {
    type: String,
    enum: ["Coffee", "Tea", "Water"],
  },
});

Catatan. Setiap model memetakan ke kumpulan dokumen di database MongoDB. Dokumen akan berisi bidang/tipe skema yang ditentukan dalam model

const breakfastSchema = new Schema({
  eggs: {
    type: Number,
    min: [6, "Too few eggs"],
    max: 12,
    required: [true, "Why no eggs?"],
  },
  drink: {
    type: String,
    enum: ["Coffee", "Tea", "Water"],
  },
});

Mendefinisikan skema

Fragmen kode di bawah ini menunjukkan bagaimana Anda dapat mendefinisikan skema sederhana. Pertama Anda

const schema = new Schema({
  name: String,
  binary: Buffer,
  living: Boolean,
  updated: { type: Date, default: Date.now() },
  age: { type: Number, min: 18, max: 65, required: true },
  mixed: Schema.Types.Mixed,
  _someId: Schema.Types.ObjectId,
  array: [],
  ofString: [String], // You can also have an array of each of the other types too.
  nested: { stuff: { type: String, lowercase: true, trim: true } },
});

// Require Mongoose
const mongoose = require("mongoose");

// Define a schema
const Schema = mongoose.Schema;

const SomeModelSchema = new Schema({
  a_string: String,
  a_date: Date,
});

Dalam kasus di atas kita hanya memiliki dua field, sebuah string dan sebuah tanggal. Di bagian selanjutnya, kami akan menunjukkan beberapa jenis bidang lainnya, validasi, dan metode lainnya

Membuat model

Model dibuat dari skema menggunakan metode

const breakfastSchema = new Schema({
  eggs: {
    type: Number,
    min: [6, "Too few eggs"],
    max: 12,
    required: [true, "Why no eggs?"],
  },
  drink: {
    type: String,
    enum: ["Coffee", "Tea", "Water"],
  },
});

// Define schema
const Schema = mongoose.Schema;

const SomeModelSchema = new Schema({
  a_string: String,
  a_date: Date,
});

// Compile model from schema
const SomeModel = mongoose.model("SomeModel", SomeModelSchema);

Argumen pertama adalah nama tunggal dari koleksi yang akan dibuat untuk model Anda (Mongoose akan membuat koleksi database untuk model SomeModel di atas), dan argumen kedua adalah skema yang ingin Anda gunakan dalam membuat model

Catatan. Setelah Anda menentukan kelas model, Anda dapat menggunakannya untuk membuat, memperbarui, atau menghapus rekaman, dan menjalankan kueri untuk mendapatkan semua rekaman atau subkumpulan rekaman tertentu. Kami akan menunjukkan cara melakukannya di bagian ini, dan saat kami membuat tampilan kami

Jenis skema (bidang)

Skema dapat memiliki jumlah bidang yang berubah-ubah — masing-masing mewakili bidang dalam dokumen yang disimpan di MongoDB. Skema contoh yang menunjukkan banyak jenis bidang umum dan cara mendeklarasikannya ditunjukkan di bawah ini

const schema = new Schema({
  name: String,
  binary: Buffer,
  living: Boolean,
  updated: { type: Date, default: Date.now() },
  age: { type: Number, min: 18, max: 65, required: true },
  mixed: Schema.Types.Mixed,
  _someId: Schema.Types.ObjectId,
  array: [],
  ofString: [String], // You can also have an array of each of the other types too.
  nested: { stuff: { type: String, lowercase: true, trim: true } },
});

Sebagian besar SchemaTypes (deskriptor setelah "type. " atau setelah nama bidang) cukup jelas. Pengecualian adalah

• const breakfastSchema = new Schema({
    eggs: {
      type: Number,
      min: [6, "Too few eggs"],
      max: 12,
      required: [true, "Why no eggs?"],
    },
    drink: {
      type: String,
      enum: ["Coffee", "Tea", "Water"],
    },
  });
  

  7. Merupakan contoh spesifik dari model dalam database. Misalnya, sebuah buku mungkin menggunakan ini untuk mewakili objek penulisnya. Ini sebenarnya akan berisi ID unik (

  // Define schema
  const Schema = mongoose.Schema;
  
  const SomeModelSchema = new Schema({
    a_string: String,
    a_date: Date,
  });
  
  // Compile model from schema
  const SomeModel = mongoose.model("SomeModel", SomeModelSchema);
  

  4) untuk objek yang ditentukan. Kita dapat menggunakan metode

  const breakfastSchema = new Schema({
    eggs: {
      type: Number,
      min: [6, "Too few eggs"],
      max: 12,
      required: [true, "Why no eggs?"],
    },
    drink: {
      type: String,
      enum: ["Coffee", "Tea", "Water"],
    },
  });
  

  _9 untuk menarik informasi terkait bila diperlukan
• Jenis skema arbitrer

• // Create an instance of model SomeModel
  const awesome_instance = new SomeModel({ name: "awesome" });
  
  // Save the new model instance, passing a callback
  awesome_instance.save((err) => {
    if (err) return handleError(err);
    // saved!
  });
  

  1. Berbagai item. Anda dapat melakukan operasi larik JavaScript pada model ini (push, pop, unshift, dll. ). Contoh di atas menunjukkan larik objek tanpa tipe tertentu dan larik

  // Create an instance of model SomeModel
  const awesome_instance = new SomeModel({ name: "awesome" });
  
  // Save the new model instance, passing a callback
  awesome_instance.save((err) => {
    if (err) return handleError(err);
    // saved!
  });
  

  2 objek, tetapi Anda dapat memiliki larik tipe objek apa pun

Kode juga menunjukkan kedua cara mendeklarasikan bidang

• Nama bidang dan ketik sebagai pasangan nilai kunci (mis. e. seperti yang dilakukan dengan bidang

  // Create an instance of model SomeModel
  const awesome_instance = new SomeModel({ name: "awesome" });
  
  // Save the new model instance, passing a callback
  awesome_instance.save((err) => {
    if (err) return handleError(err);
    // saved!
  });
  

  3,

  // Create an instance of model SomeModel
  const awesome_instance = new SomeModel({ name: "awesome" });
  
  // Save the new model instance, passing a callback
  awesome_instance.save((err) => {
    if (err) return handleError(err);
    // saved!
  });
  

  4 dan

  // Create an instance of model SomeModel
  const awesome_instance = new SomeModel({ name: "awesome" });
  
  // Save the new model instance, passing a callback
  awesome_instance.save((err) => {
    if (err) return handleError(err);
    // saved!
  });
  

  5)
• Nama bidang diikuti dengan objek yang mendefinisikan

  // Create an instance of model SomeModel
  const awesome_instance = new SomeModel({ name: "awesome" });
  
  // Save the new model instance, passing a callback
  awesome_instance.save((err) => {
    if (err) return handleError(err);
    // saved!
  });
  

  6, dan opsi lain untuk bidang tersebut. Opsi mencakup hal-hal seperti
  • nilai dasar
  • validator bawaan (mis. g. nilai maks/min) dan fungsi validasi khusus
  • Apakah bidang itu diperlukan
  • Apakah bidang

    // Create an instance of model SomeModel
    const awesome_instance = new SomeModel({ name: "awesome" });
    
    // Save the new model instance, passing a callback
    awesome_instance.save((err) => {
      if (err) return handleError(err);
      // saved!
    });
    

    _2 harus secara otomatis disetel ke huruf kecil, huruf besar, atau dipangkas (mis. g.

    // Create an instance of model SomeModel
    const awesome_instance = new SomeModel({ name: "awesome" });
    
    // Save the new model instance, passing a callback
    awesome_instance.save((err) => {
      if (err) return handleError(err);
      // saved!
    });
    

    8)

Untuk informasi lebih lanjut tentang opsi, lihat SchemaTypes (Mongoose docs)

Validasi

Mongoose menyediakan validator bawaan dan kustom, serta validator sinkron dan asinkron. Ini memungkinkan Anda menentukan rentang nilai yang dapat diterima dan pesan kesalahan untuk kegagalan validasi dalam semua kasus

Validator bawaan termasuk

• Semua Jenis Skema memiliki validator bawaan. Ini digunakan untuk menentukan apakah bidang harus disediakan untuk menyimpan dokumen
• miliki dan validator
• memiliki
  • menentukan kumpulan nilai yang diizinkan untuk bidang
  • menentukan ekspresi reguler yang harus cocok dengan string
  • dan untuk string

Contoh di bawah ini (sedikit dimodifikasi dari dokumen Mongoose) menunjukkan bagaimana Anda dapat menentukan beberapa jenis validator dan pesan kesalahan

const breakfastSchema = new Schema({
  eggs: {
    type: Number,
    min: [6, "Too few eggs"],
    max: 12,
    required: [true, "Why no eggs?"],
  },
  drink: {
    type: String,
    enum: ["Coffee", "Tea", "Water"],
  },
});

Untuk informasi lengkap tentang validasi lapangan, lihat Validasi (dokumen Mongoose)

Properti maya

Properti virtual adalah properti dokumen yang bisa Anda dapatkan dan atur tetapi tidak dipertahankan ke MongoDB. Getter berguna untuk memformat atau menggabungkan bidang, sedangkan setter berguna untuk mendekomposisi satu nilai menjadi beberapa nilai untuk penyimpanan. Contoh dalam dokumentasi membuat (dan mendekonstruksi) properti virtual nama lengkap dari bidang nama depan dan belakang, yang lebih mudah dan bersih daripada membuat nama lengkap setiap kali digunakan dalam templat

Catatan. Kami akan menggunakan properti virtual di pustaka untuk menentukan URL unik untuk setiap rekaman model menggunakan jalur dan nilai

// Define schema
const Schema = mongoose.Schema;

const SomeModelSchema = new Schema({
  a_string: String,
  a_date: Date,
});

// Compile model from schema
const SomeModel = mongoose.model("SomeModel", SomeModelSchema);

Untuk informasi lebih lanjut, lihat (dokumentasi Mongoose)

Metode dan bantuan kueri

Skema juga dapat memiliki , , dan. Metode instance dan statis serupa, tetapi dengan perbedaan yang jelas bahwa metode instance dikaitkan dengan catatan tertentu dan memiliki akses ke objek saat ini. Pembantu kueri memungkinkan Anda memperluas API pembuat kueri yang dapat dirangkai dari luwak (misalnya, memungkinkan Anda menambahkan kueri "berdasarkan Nama" selain metode

SomeModel.create({ name: "also_awesome" }, function (err, awesome_instance) {
  if (err) return handleError(err);
  // saved!
});

SomeModel.create({ name: "also_awesome" }, function (err, awesome_instance) {
  if (err) return handleError(err);
  // saved!
});

SomeModel.create({ name: "also_awesome" }, function (err, awesome_instance) {
  if (err) return handleError(err);
  // saved!
});

Setelah membuat skema, Anda dapat menggunakannya untuk membuat model. Model mewakili kumpulan dokumen dalam database yang dapat Anda cari, sedangkan instance model mewakili dokumen individu yang dapat Anda simpan dan ambil

Kami memberikan gambaran singkat di bawah ini. Untuk informasi lebih lanjut lihat. Model (dokumen Mongoose)

Membuat dan memodifikasi dokumen

Untuk membuat rekaman, Anda dapat menentukan instance model dan kemudian memanggil

SomeModel.create({ name: "also_awesome" }, function (err, awesome_instance) {
  if (err) return handleError(err);
  // saved!
});

// Create an instance of model SomeModel
const awesome_instance = new SomeModel({ name: "awesome" });

// Save the new model instance, passing a callback
awesome_instance.save((err) => {
  if (err) return handleError(err);
  // saved!
});

Pembuatan catatan (bersama dengan pembaruan, penghapusan, dan kueri) adalah operasi asinkron — Anda memberikan panggilan balik yang dipanggil saat operasi selesai. API menggunakan konvensi argumen error-first, jadi argumen pertama untuk callback akan selalu berupa nilai error (atau null). Jika API mengembalikan beberapa hasil, ini akan diberikan sebagai argumen kedua

Anda juga dapat menggunakan

SomeModel.create({ name: "also_awesome" }, function (err, awesome_instance) {
  if (err) return handleError(err);
  // saved!
});

SomeModel.create({ name: "also_awesome" }, function (err, awesome_instance) {
  if (err) return handleError(err);
  // saved!
});

Setiap model memiliki koneksi terkait (ini akan menjadi koneksi default saat Anda menggunakan

const breakfastSchema = new Schema({
  eggs: {
    type: Number,
    min: [6, "Too few eggs"],
    max: 12,
    required: [true, "Why no eggs?"],
  },
  drink: {
    type: String,
    enum: ["Coffee", "Tea", "Water"],
  },
});

SomeModel.create({ name: "also_awesome" }, function (err, awesome_instance) {
  if (err) return handleError(err);
  // saved!
});

Anda dapat mengakses bidang dalam catatan baru ini menggunakan sintaks titik, dan mengubah nilainya. Anda harus memanggil

SomeModel.create({ name: "also_awesome" }, function (err, awesome_instance) {
  if (err) return handleError(err);
  // saved!
});

SomeModel.create({ name: "also_awesome" }, function (err, awesome_instance) {
  if (err) return handleError(err);
  // saved!
});

// Access model field values using dot notation
console.log(awesome_instance.name); //should log 'also_awesome'

// Change record by modifying the fields, then calling save().
awesome_instance.name = "New cool name";
awesome_instance.save((err) => {
  if (err) return handleError(err); // saved!
});

Mencari rekaman

Anda dapat mencari catatan menggunakan metode kueri, menentukan kondisi kueri sebagai dokumen JSON. Fragmen kode di bawah ini menunjukkan bagaimana Anda dapat menemukan semua atlet dalam database yang bermain tenis, hanya menampilkan bidang untuk nama dan usia atlet. Di sini kami hanya menentukan satu bidang yang cocok (olahraga), tetapi Anda dapat menambahkan lebih banyak kriteria, menentukan kriteria ekspresi reguler, atau menghapus semua ketentuan untuk mengembalikan semua atlet

const Athlete = mongoose.model("Athlete", yourSchema);

// find all athletes who play tennis, selecting the 'name' and 'age' fields
Athlete.find({ sport: "Tennis" }, "name age", (err, athletes) => {
  if (err) return handleError(err);
  // 'athletes' contains the list of athletes that match the criteria.
});

Jika Anda menentukan panggilan balik, seperti yang ditunjukkan di atas, kueri akan segera dijalankan. Panggilan balik akan dipanggil saat pencarian selesai

Catatan. Semua callback di Mongoose menggunakan pola

SomeModel.create({ name: "also_awesome" }, function (err, awesome_instance) {
  if (err) return handleError(err);
  // saved!
});

// Access model field values using dot notation
console.log(awesome_instance.name); //should log 'also_awesome'

// Change record by modifying the fields, then calling save().
awesome_instance.name = "New cool name";
awesome_instance.save((err) => {
  if (err) return handleError(err); // saved!
});

// Access model field values using dot notation
console.log(awesome_instance.name); //should log 'also_awesome'

// Change record by modifying the fields, then calling save().
awesome_instance.name = "New cool name";
awesome_instance.save((err) => {
  if (err) return handleError(err); // saved!
});

// Access model field values using dot notation
console.log(awesome_instance.name); //should log 'also_awesome'

// Change record by modifying the fields, then calling save().
awesome_instance.name = "New cool name";
awesome_instance.save((err) => {
  if (err) return handleError(err); // saved!
});

// Access model field values using dot notation
console.log(awesome_instance.name); //should log 'also_awesome'

// Change record by modifying the fields, then calling save().
awesome_instance.name = "New cool name";
awesome_instance.save((err) => {
  if (err) return handleError(err); // saved!
});

Catatan. Penting untuk diingat bahwa tidak menemukan hasil apa pun bukanlah kesalahan untuk pencarian — tetapi ini mungkin merupakan kasus gagal dalam konteks aplikasi Anda. Jika aplikasi Anda mengharapkan pencarian untuk menemukan nilai, Anda dapat memeriksa hasilnya di callback (

// Access model field values using dot notation
console.log(awesome_instance.name); //should log 'also_awesome'

// Change record by modifying the fields, then calling save().
awesome_instance.name = "New cool name";
awesome_instance.save((err) => {
  if (err) return handleError(err); // saved!
});

Jika Anda tidak menentukan callback maka API akan mengembalikan variabel tipe. Anda dapat menggunakan objek kueri ini untuk membangun kueri Anda dan kemudian menjalankannya (dengan panggilan balik) nanti menggunakan metode

// Access model field values using dot notation
console.log(awesome_instance.name); //should log 'also_awesome'

// Change record by modifying the fields, then calling save().
awesome_instance.name = "New cool name";
awesome_instance.save((err) => {
  if (err) return handleError(err); // saved!
});

// Import the mongoose module
const mongoose = require("mongoose");

// Set `strictQuery: false` to globally opt into filtering by properties that aren't in the schema
// Included because it removes preparatory warnings for Mongoose 7.
// See: https://mongoosejs.com/docs/migrating_to_6.html#strictquery-is-removed-and-replaced-by-strict
mongoose.set('strictQuery', false);

// Define the database URL to connect to.
const mongoDB = "mongodb://127.0.0.1/my_database";

// Wait for database to connect, logging an error if there is a problem 
main().catch(err => console.log(err));
async function main() {
  await mongoose.connect(mongoDB);
}

Di atas kami telah mendefinisikan kondisi kueri dalam metode

SomeModel.create({ name: "also_awesome" }, function (err, awesome_instance) {
  if (err) return handleError(err);
  // saved!
});

// Access model field values using dot notation
console.log(awesome_instance.name); //should log 'also_awesome'

// Change record by modifying the fields, then calling save().
awesome_instance.name = "New cool name";
awesome_instance.save((err) => {
  if (err) return handleError(err); // saved!
});

// Import the mongoose module
const mongoose = require("mongoose");

// Set `strictQuery: false` to globally opt into filtering by properties that aren't in the schema
// Included because it removes preparatory warnings for Mongoose 7.
// See: https://mongoosejs.com/docs/migrating_to_6.html#strictquery-is-removed-and-replaced-by-strict
mongoose.set('strictQuery', false);

// Define the database URL to connect to.
const mongoDB = "mongodb://127.0.0.1/my_database";

// Wait for database to connect, logging an error if there is a problem 
main().catch(err => console.log(err));
async function main() {
  await mongoose.connect(mongoDB);
}

Metode ini mendapatkan semua data yang cocok, tetapi seringkali Anda hanya ingin mendapatkan satu kecocokan. Metode berikut melakukan kueri untuk satu rekaman

• Menemukan dokumen dengan

  // Access model field values using dot notation
  console.log(awesome_instance.name); //should log 'also_awesome'
  
  // Change record by modifying the fields, then calling save().
  awesome_instance.name = "New cool name";
  awesome_instance.save((err) => {
    if (err) return handleError(err); // saved!
  });
  

  _9 yang ditentukan (setiap dokumen memiliki

  // Access model field values using dot notation
  console.log(awesome_instance.name); //should log 'also_awesome'
  
  // Change record by modifying the fields, then calling save().
  awesome_instance.name = "New cool name";
  awesome_instance.save((err) => {
    if (err) return handleError(err); // saved!
  });
  

  9 yang unik)
• Menemukan satu dokumen yang cocok dengan kriteria yang ditentukan
• , , ,. Menemukan satu dokumen dengan

  // Access model field values using dot notation
  console.log(awesome_instance.name); //should log 'also_awesome'
  
  // Change record by modifying the fields, then calling save().
  awesome_instance.name = "New cool name";
  awesome_instance.save((err) => {
    if (err) return handleError(err); // saved!
  });
  

  _9 atau kriteria dan memperbarui atau menghapusnya. Ini adalah fungsi kenyamanan yang berguna untuk memperbarui dan menghapus catatan

Catatan. Ada juga cara yang bisa kamu gunakan untuk mendapatkan jumlah item yang sesuai dengan kondisi. Ini berguna jika Anda ingin melakukan penghitungan tanpa benar-benar mengambil rekamannya

Ada banyak lagi yang dapat Anda lakukan dengan kueri. Untuk informasi lebih lanjut lihat. Kueri (dokumen Mongoose)

Bekerja dengan dokumen terkait — populasi

Anda dapat membuat referensi dari satu dokumen/contoh model ke yang lain menggunakan bidang skema

const breakfastSchema = new Schema({
  eggs: {
    type: Number,
    min: [6, "Too few eggs"],
    max: 12,
    required: [true, "Why no eggs?"],
  },
  drink: {
    type: String,
    enum: ["Coffee", "Tea", "Water"],
  },
});

const Athlete = mongoose.model("Athlete", yourSchema);

// find all athletes who play tennis, selecting the 'name' and 'age' fields
Athlete.find({ sport: "Tennis" }, "name age", (err, athletes) => {
  if (err) return handleError(err);
  // 'athletes' contains the list of athletes that match the criteria.
});

Misalnya, skema berikut mendefinisikan penulis dan cerita. Setiap penulis dapat memiliki banyak cerita, yang kami wakili sebagai larik

const breakfastSchema = new Schema({
  eggs: {
    type: Number,
    min: [6, "Too few eggs"],
    max: 12,
    required: [true, "Why no eggs?"],
  },
  drink: {
    type: String,
    enum: ["Coffee", "Tea", "Water"],
  },
});

// Import the mongoose module
const mongoose = require("mongoose");

// Set `strictQuery: false` to globally opt into filtering by properties that aren't in the schema
// Included because it removes preparatory warnings for Mongoose 7.
// See: https://mongoosejs.com/docs/migrating_to_6.html#strictquery-is-removed-and-replaced-by-strict
mongoose.set('strictQuery', false);

// Define the database URL to connect to.
const mongoDB = "mongodb://127.0.0.1/my_database";

// Wait for database to connect, logging an error if there is a problem 
main().catch(err => console.log(err));
async function main() {
  await mongoose.connect(mongoDB);
}

// Import the mongoose module
const mongoose = require("mongoose");

// Set `strictQuery: false` to globally opt into filtering by properties that aren't in the schema
// Included because it removes preparatory warnings for Mongoose 7.
// See: https://mongoosejs.com/docs/migrating_to_6.html#strictquery-is-removed-and-replaced-by-strict
mongoose.set('strictQuery', false);

// Define the database URL to connect to.
const mongoDB = "mongodb://127.0.0.1/my_database";

// Wait for database to connect, logging an error if there is a problem 
main().catch(err => console.log(err));
async function main() {
  await mongoose.connect(mongoDB);
}

Kami dapat menyimpan referensi kami ke dokumen terkait dengan menetapkan nilai

// Define schema
const Schema = mongoose.Schema;

const SomeModelSchema = new Schema({
  a_string: String,
  a_date: Date,
});

// Compile model from schema
const SomeModel = mongoose.model("SomeModel", SomeModelSchema);

// Import the mongoose module
const mongoose = require("mongoose");

// Set `strictQuery: false` to globally opt into filtering by properties that aren't in the schema
// Included because it removes preparatory warnings for Mongoose 7.
// See: https://mongoosejs.com/docs/migrating_to_6.html#strictquery-is-removed-and-replaced-by-strict
mongoose.set('strictQuery', false);

// Define the database URL to connect to.
const mongoDB = "mongodb://127.0.0.1/my_database";

// Wait for database to connect, logging an error if there is a problem 
main().catch(err => console.log(err));
async function main() {
  await mongoose.connect(mongoDB);
}

Dokumen cerita kita sekarang memiliki penulis yang direferensikan oleh ID dokumen penulis. Untuk mendapatkan informasi penulis dalam hasil cerita kami menggunakan

const breakfastSchema = new Schema({
  eggs: {
    type: Number,
    min: [6, "Too few eggs"],
    max: 12,
    required: [true, "Why no eggs?"],
  },
  drink: {
    type: String,
    enum: ["Coffee", "Tea", "Water"],
  },
});

// Import the mongoose module
const mongoose = require("mongoose");

// Set `strictQuery: false` to globally opt into filtering by properties that aren't in the schema
// Included because it removes preparatory warnings for Mongoose 7.
// See: https://mongoosejs.com/docs/migrating_to_6.html#strictquery-is-removed-and-replaced-by-strict
mongoose.set('strictQuery', false);

// Define the database URL to connect to.
const mongoDB = "mongodb://127.0.0.1/my_database";

// Wait for database to connect, logging an error if there is a problem 
main().catch(err => console.log(err));
async function main() {
  await mongoose.connect(mongoDB);
}

Catatan. Pembaca yang cerdik akan mencatat bahwa kami menambahkan penulis ke cerita kami, tetapi kami tidak melakukan apa pun untuk menambahkan cerita kami ke susunan

// Import the mongoose module
const mongoose = require("mongoose");

// Set `strictQuery: false` to globally opt into filtering by properties that aren't in the schema
// Included because it removes preparatory warnings for Mongoose 7.
// See: https://mongoosejs.com/docs/migrating_to_6.html#strictquery-is-removed-and-replaced-by-strict
mongoose.set('strictQuery', false);

// Define the database URL to connect to.
const mongoDB = "mongodb://127.0.0.1/my_database";

// Wait for database to connect, logging an error if there is a problem 
main().catch(err => console.log(err));
async function main() {
  await mongoose.connect(mongoDB);
}

Cara yang lebih baik adalah mendapatkan

// Define schema
const Schema = mongoose.Schema;

const SomeModelSchema = new Schema({
  a_string: String,
  a_date: Date,
});

// Compile model from schema
const SomeModel = mongoose.model("SomeModel", SomeModelSchema);

SomeModel.create({ name: "also_awesome" }, function (err, awesome_instance) {
  if (err) return handleError(err);
  // saved!
});

// Import the mongoose module
const mongoose = require("mongoose");

// Set `strictQuery: false` to globally opt into filtering by properties that aren't in the schema
// Included because it removes preparatory warnings for Mongoose 7.
// See: https://mongoosejs.com/docs/migrating_to_6.html#strictquery-is-removed-and-replaced-by-strict
mongoose.set('strictQuery', false);

// Define the database URL to connect to.
const mongoDB = "mongodb://127.0.0.1/my_database";

// Wait for database to connect, logging an error if there is a problem 
main().catch(err => console.log(err));
async function main() {
  await mongoose.connect(mongoDB);
}

Ini hampir semua yang perlu Anda ketahui tentang bekerja dengan item terkait untuk tutorial ini. Untuk informasi lebih rinci, lihat Populasi (Mongoose docs)

Meskipun Anda dapat membuat skema dan model menggunakan struktur file apa pun yang Anda suka, kami sangat menyarankan untuk menentukan setiap skema model dalam modulnya sendiri (file), lalu mengekspor metode untuk membuat model. Ini ditunjukkan di bawah ini

// Import the mongoose module
const mongoose = require("mongoose");

// Set `strictQuery: false` to globally opt into filtering by properties that aren't in the schema
// Included because it removes preparatory warnings for Mongoose 7.
// See: https://mongoosejs.com/docs/migrating_to_6.html#strictquery-is-removed-and-replaced-by-strict
mongoose.set('strictQuery', false);

// Define the database URL to connect to.
const mongoDB = "mongodb://127.0.0.1/my_database";

// Wait for database to connect, logging an error if there is a problem 
main().catch(err => console.log(err));
async function main() {
  await mongoose.connect(mongoDB);
}

Anda kemudian dapat meminta dan menggunakan model tersebut segera di file lain. Di bawah ini kami menunjukkan bagaimana Anda dapat menggunakannya untuk mendapatkan semua contoh model

// Import the mongoose module
const mongoose = require("mongoose");

// Set `strictQuery: false` to globally opt into filtering by properties that aren't in the schema
// Included because it removes preparatory warnings for Mongoose 7.
// See: https://mongoosejs.com/docs/migrating_to_6.html#strictquery-is-removed-and-replaced-by-strict
mongoose.set('strictQuery', false);

// Define the database URL to connect to.
const mongoDB = "mongodb://127.0.0.1/my_database";

// Wait for database to connect, logging an error if there is a problem 
main().catch(err => console.log(err));
async function main() {
  await mongoose.connect(mongoDB);
}

Sekarang setelah kita memahami sesuatu tentang apa yang dapat dilakukan Mongoose dan bagaimana kita ingin mendesain model kita, saatnya untuk mulai bekerja di situs web LocalLibrary. Hal pertama yang ingin kita lakukan adalah menyiapkan database MongoDB yang dapat kita gunakan untuk menyimpan data perpustakaan kita

Untuk tutorial ini, kita akan menggunakan database kotak pasir yang dihosting cloud MongoDB Atlas. Tingkat basis data ini dianggap tidak cocok untuk situs web produksi karena tidak memiliki redundansi, tetapi bagus untuk pengembangan dan pembuatan prototipe. Kami menggunakannya di sini karena gratis dan mudah disiapkan, dan karena MongoDB Atlas adalah database populer sebagai vendor layanan yang mungkin Anda pilih secara wajar untuk database produksi Anda (pilihan populer lainnya pada saat penulisan termasuk Compose, ScaleGrid

Catatan. Jika mau, Anda dapat menyiapkan database MongoDb secara lokal dengan mengunduh dan menginstal binari yang sesuai untuk sistem Anda. Petunjuk lainnya dalam artikel ini akan serupa, kecuali untuk URL basis data yang akan Anda tentukan saat menghubungkan. Dalam Tutorial Ekspres Bagian 7. Menyebarkan ke tutorial Produksi kami menghosting aplikasi dan database di Railway, tetapi kami juga bisa menggunakan database di MongoDB Atlas

Pertama-tama Anda harus membuat akun dengan MongoDB Atlas (ini gratis, dan Anda hanya perlu memasukkan detail kontak dasar dan mengetahui persyaratan layanan mereka)

Setelah masuk, Anda akan dibawa ke layar beranda

1. Klik tombol Build a Database di bagian Database Deployment.
   
2. Ini akan membuka layar Deploy a cloud database. Klik tombol Create di bawah opsi Shared deployment.
   
3. Ini akan membuka layar Create a Shared Cluster.
   
   • Pilih salah satu penyedia dari bagian Cloud Provider & Region. Daerah yang berbeda menawarkan penyedia yang berbeda.
   • Tingkat Cluster dan Pengaturan Tambahan tidak perlu diubah. Anda dapat mengubah nama Cluster Anda di bawah Nama Cluster. Kami menamakannya

     // Import the mongoose module
     const mongoose = require("mongoose");
     
     // Set `strictQuery: false` to globally opt into filtering by properties that aren't in the schema
     // Included because it removes preparatory warnings for Mongoose 7.
     // See: https://mongoosejs.com/docs/migrating_to_6.html#strictquery-is-removed-and-replaced-by-strict
     mongoose.set('strictQuery', false);
     
     // Define the database URL to connect to.
     const mongoDB = "mongodb://127.0.0.1/my_database";
     
     // Wait for database to connect, logging an error if there is a problem 
     main().catch(err => console.log(err));
     async function main() {
       await mongoose.connect(mongoDB);
     }
     

     _08 untuk tutorial ini
   • Klik tombol Create Cluster (pembuatan cluster akan memakan waktu beberapa menit)
4. Ini akan membuka bagian Quickstart Keamanan.
   
   • Masukkan nama pengguna dan sandi. Ingatlah untuk menyalin dan menyimpan kredensial dengan aman karena kami akan membutuhkannya nanti. Klik tombol Buat Pengguna.

     Catatan. Hindari penggunaan karakter khusus dalam kata sandi pengguna MongoDB Anda karena luwak mungkin tidak mengurai string koneksi dengan benar

   • Masukkan

     // Import the mongoose module
     const mongoose = require("mongoose");
     
     // Set `strictQuery: false` to globally opt into filtering by properties that aren't in the schema
     // Included because it removes preparatory warnings for Mongoose 7.
     // See: https://mongoosejs.com/docs/migrating_to_6.html#strictquery-is-removed-and-replaced-by-strict
     mongoose.set('strictQuery', false);
     
     // Define the database URL to connect to.
     const mongoDB = "mongodb://127.0.0.1/my_database";
     
     // Wait for database to connect, logging an error if there is a problem 
     main().catch(err => console.log(err));
     async function main() {
       await mongoose.connect(mongoDB);
     }
     

     _09 di bidang Alamat IP. Ini memberi tahu MongoDB bahwa kami ingin mengizinkan akses dari mana saja. Klik tombol Tambah Entri

     Catatan. Ini adalah praktik terbaik untuk membatasi alamat IP yang dapat terhubung ke database Anda dan sumber daya lainnya. Di sini kami mengizinkan koneksi dari mana saja karena kami tidak tahu dari mana permintaan akan datang setelah penerapan

   • Klik tombol Selesai dan Tutup
5. Ini akan membuka layar berikut. Klik tombol Buka Database.
   
6. Anda akan kembali ke layar Penerapan Database. Klik tombol Telusuri Koleksi.
   
7. Ini akan membuka bagian Koleksi. Klik tombol Tambahkan Data Saya Sendiri.
   
8. Ini akan membuka layar Create Database.
   
   • Masukkan nama untuk database baru sebagai

     // Import the mongoose module
     const mongoose = require("mongoose");
     
     // Set `strictQuery: false` to globally opt into filtering by properties that aren't in the schema
     // Included because it removes preparatory warnings for Mongoose 7.
     // See: https://mongoosejs.com/docs/migrating_to_6.html#strictquery-is-removed-and-replaced-by-strict
     mongoose.set('strictQuery', false);
     
     // Define the database URL to connect to.
     const mongoDB = "mongodb://127.0.0.1/my_database";
     
     // Wait for database to connect, logging an error if there is a problem 
     main().catch(err => console.log(err));
     async function main() {
       await mongoose.connect(mongoDB);
     }
     

     10.
   • Masukkan nama koleksi sebagai

     // Import the mongoose module
     const mongoose = require("mongoose");
     
     // Set `strictQuery: false` to globally opt into filtering by properties that aren't in the schema
     // Included because it removes preparatory warnings for Mongoose 7.
     // See: https://mongoosejs.com/docs/migrating_to_6.html#strictquery-is-removed-and-replaced-by-strict
     mongoose.set('strictQuery', false);
     
     // Define the database URL to connect to.
     const mongoDB = "mongodb://127.0.0.1/my_database";
     
     // Wait for database to connect, logging an error if there is a problem 
     main().catch(err => console.log(err));
     async function main() {
       await mongoose.connect(mongoDB);
     }
     

     11
   • Klik tombol Create untuk membuat database
9. Anda akan kembali ke layar Collections dengan database Anda telah dibuat.
   
   • Klik tab Ikhtisar untuk kembali ke ikhtisar kluster.
10. Dari layar Tinjauan Cluster0, klik tombol Hubungkan.
    
11. Ini akan membuka layar Connect to Cluster. Klik opsi Hubungkan aplikasi Anda.
    
12. Sekarang Anda akan diperlihatkan layar Connect.
    
    • Pilih driver dan versi Node seperti yang ditunjukkan.
    • Klik ikon Salin untuk menyalin string koneksi
    • Rekatkan ini di editor teks lokal Anda
    • Perbarui nama pengguna dan kata sandi dengan kata sandi pengguna Anda
    • Masukkan nama database "local_library" di jalur sebelum opsi (

      // Import the mongoose module
      const mongoose = require("mongoose");
      
      // Set `strictQuery: false` to globally opt into filtering by properties that aren't in the schema
      // Included because it removes preparatory warnings for Mongoose 7.
      // See: https://mongoosejs.com/docs/migrating_to_6.html#strictquery-is-removed-and-replaced-by-strict
      mongoose.set('strictQuery', false);
      
      // Define the database URL to connect to.
      const mongoDB = "mongodb://127.0.0.1/my_database";
      
      // Wait for database to connect, logging an error if there is a problem 
      main().catch(err => console.log(err));
      async function main() {
        await mongoose.connect(mongoDB);
      }
      

      12)
    • Simpan file yang berisi string ini di tempat yang aman

Anda sekarang telah membuat database, dan memiliki URL (dengan nama pengguna dan kata sandi) yang dapat digunakan untuk mengaksesnya. Ini akan terlihat seperti.

// Import the mongoose module
const mongoose = require("mongoose");

// Set `strictQuery: false` to globally opt into filtering by properties that aren't in the schema
// Included because it removes preparatory warnings for Mongoose 7.
// See: https://mongoosejs.com/docs/migrating_to_6.html#strictquery-is-removed-and-replaced-by-strict
mongoose.set('strictQuery', false);

// Define the database URL to connect to.
const mongoDB = "mongodb://127.0.0.1/my_database";

// Wait for database to connect, logging an error if there is a problem 
main().catch(err => console.log(err));
async function main() {
  await mongoose.connect(mongoDB);
}

Buka prompt perintah dan navigasikan ke direktori tempat Anda membuat situs web Perpustakaan Lokal kerangka Anda. Masukkan perintah berikut untuk menginstal Mongoose (dan dependensinya) dan tambahkan ke paket Anda. json, kecuali Anda sudah melakukannya saat membaca di atas

npm install mongoose

Buka /aplikasi. js (di root proyek Anda) dan salin teks berikut di bawah tempat Anda mendeklarasikan objek aplikasi Express (setelah baris

// Import the mongoose module
const mongoose = require("mongoose");

// Set `strictQuery: false` to globally opt into filtering by properties that aren't in the schema
// Included because it removes preparatory warnings for Mongoose 7.
// See: https://mongoosejs.com/docs/migrating_to_6.html#strictquery-is-removed-and-replaced-by-strict
mongoose.set('strictQuery', false);

// Define the database URL to connect to.
const mongoDB = "mongodb://127.0.0.1/my_database";

// Wait for database to connect, logging an error if there is a problem 
main().catch(err => console.log(err));
async function main() {
  await mongoose.connect(mongoDB);
}

// Import the mongoose module
const mongoose = require("mongoose");

// Set `strictQuery: false` to globally opt into filtering by properties that aren't in the schema
// Included because it removes preparatory warnings for Mongoose 7.
// See: https://mongoosejs.com/docs/migrating_to_6.html#strictquery-is-removed-and-replaced-by-strict
mongoose.set('strictQuery', false);

// Define the database URL to connect to.
const mongoDB = "mongodb://127.0.0.1/my_database";

// Wait for database to connect, logging an error if there is a problem 
main().catch(err => console.log(err));
async function main() {
  await mongoose.connect(mongoDB);
}

Seperti yang telah dibahas, kode ini membuat koneksi default ke database dan melaporkan kesalahan apa pun ke konsol

Kami akan menentukan modul terpisah untuk setiap model, seperti. Mulailah dengan membuat folder untuk model kita di root proyek (/models) dan kemudian buat file terpisah untuk masing-masing model

// Require Mongoose
const mongoose = require("mongoose");

// Define a schema
const Schema = mongoose.Schema;

const SomeModelSchema = new Schema({
  a_string: String,
  a_date: Date,
});

Salin kode skema

// Define schema
const Schema = mongoose.Schema;

const SomeModelSchema = new Schema({
  a_string: String,
  a_date: Date,
});

// Compile model from schema
const SomeModel = mongoose.model("SomeModel", SomeModelSchema);

// Create an instance of model SomeModel
const awesome_instance = new SomeModel({ name: "awesome" });

// Save the new model instance, passing a callback
awesome_instance.save((err) => {
  if (err) return handleError(err);
  // saved!
});

// Import the mongoose module
const mongoose = require("mongoose");

// Set `strictQuery: false` to globally opt into filtering by properties that aren't in the schema
// Included because it removes preparatory warnings for Mongoose 7.
// See: https://mongoosejs.com/docs/migrating_to_6.html#strictquery-is-removed-and-replaced-by-strict
mongoose.set('strictQuery', false);

// Define the database URL to connect to.
const mongoDB = "mongodb://127.0.0.1/my_database";

// Wait for database to connect, logging an error if there is a problem 
main().catch(err => console.log(err));
async function main() {
  await mongoose.connect(mongoDB);
}

// Require Mongoose
const mongoose = require("mongoose");

// Define a schema
const Schema = mongoose.Schema;

const SomeModelSchema = new Schema({
  a_string: String,
  a_date: Date,
});

Kami juga telah mendeklarasikan untuk AuthorSchema bernama "url" yang mengembalikan URL absolut yang diperlukan untuk mendapatkan instance model tertentu — kami akan menggunakan properti di template kami kapan pun kami perlu mendapatkan link ke penulis tertentu

Catatan. Mendeklarasikan URL kami sebagai virtual dalam skema adalah ide yang bagus karena URL untuk item hanya perlu diubah di satu tempat. Pada titik ini, tautan yang menggunakan URL ini tidak akan berfungsi, karena kami tidak memiliki rute yang menangani kode untuk instance model individual. Kami akan menyiapkannya di artikel selanjutnya

Di akhir modul, kami mengekspor model

Salin kode skema

// Require Mongoose
const mongoose = require("mongoose");

// Define a schema
const Schema = mongoose.Schema;

const SomeModelSchema = new Schema({
  a_string: String,
  a_date: Date,
});

// Require Mongoose
const mongoose = require("mongoose");

// Define a schema
const Schema = mongoose.Schema;

const SomeModelSchema = new Schema({
  a_string: String,
  a_date: Date,
});

Perbedaan utama di sini adalah kami telah membuat dua referensi untuk model lain

• penulis adalah referensi ke objek model

  // Define schema
  const Schema = mongoose.Schema;
  
  const SomeModelSchema = new Schema({
    a_string: String,
    a_date: Date,
  });
  
  // Compile model from schema
  const SomeModel = mongoose.model("SomeModel", SomeModelSchema);
  

  8 tunggal, dan diperlukan
• genre adalah referensi ke array

  // Require Mongoose
  const mongoose = require("mongoose");
  
  // Define a schema
  const Schema = mongoose.Schema;
  
  const SomeModelSchema = new Schema({
    a_string: String,
    a_date: Date,
  });
  

  8 objek model. Kami belum mendeklarasikan objek ini

Terakhir, salin kode skema

const schema = new Schema({
  name: String,
  binary: Buffer,
  living: Boolean,
  updated: { type: Date, default: Date.now() },
  age: { type: Number, min: 18, max: 65, required: true },
  mixed: Schema.Types.Mixed,
  _someId: Schema.Types.ObjectId,
  array: [],
  ofString: [String], // You can also have an array of each of the other types too.
  nested: { stuff: { type: String, lowercase: true, trim: true } },
});

const schema = new Schema({
  name: String,
  binary: Buffer,
  living: Boolean,
  updated: { type: Date, default: Date.now() },
  age: { type: Number, min: 18, max: 65, required: true },
  mixed: Schema.Types.Mixed,
  _someId: Schema.Types.ObjectId,
  array: [],
  ofString: [String], // You can also have an array of each of the other types too.
  nested: { stuff: { type: String, lowercase: true, trim: true } },
});

// Require Mongoose
const mongoose = require("mongoose");

// Define a schema
const Schema = mongoose.Schema;

const SomeModelSchema = new Schema({
  a_string: String,
  a_date: Date,
});

Hal-hal baru yang kami tampilkan di sini adalah opsi bidang

• // Import the mongoose module
  const mongoose = require("mongoose");
  
  // Set `strictQuery: false` to globally opt into filtering by properties that aren't in the schema
  // Included because it removes preparatory warnings for Mongoose 7.
  // See: https://mongoosejs.com/docs/migrating_to_6.html#strictquery-is-removed-and-replaced-by-strict
  mongoose.set('strictQuery', false);
  
  // Define the database URL to connect to.
  const mongoDB = "mongodb://127.0.0.1/my_database";
  
  // Wait for database to connect, logging an error if there is a problem 
  main().catch(err => console.log(err));
  async function main() {
    await mongoose.connect(mongoDB);
  }
  

  _23. Ini memungkinkan kita untuk mengatur nilai string yang diizinkan. Dalam hal ini, kami menggunakannya untuk menentukan status ketersediaan buku kami (menggunakan enum berarti kami dapat mencegah salah ejaan dan nilai arbitrer untuk status kami)

• // Import the mongoose module
  const mongoose = require("mongoose");
  
  // Set `strictQuery: false` to globally opt into filtering by properties that aren't in the schema
  // Included because it removes preparatory warnings for Mongoose 7.
  // See: https://mongoosejs.com/docs/migrating_to_6.html#strictquery-is-removed-and-replaced-by-strict
  mongoose.set('strictQuery', false);
  
  // Define the database URL to connect to.
  const mongoDB = "mongodb://127.0.0.1/my_database";
  
  // Wait for database to connect, logging an error if there is a problem 
  main().catch(err => console.log(err));
  async function main() {
    await mongoose.connect(mongoDB);
  }
  

  _24. Kami menggunakan default untuk menyetel status default untuk instans buku yang baru dibuat ke pemeliharaan dan tanggal

  // Import the mongoose module
  const mongoose = require("mongoose");
  
  // Set `strictQuery: false` to globally opt into filtering by properties that aren't in the schema
  // Included because it removes preparatory warnings for Mongoose 7.
  // See: https://mongoosejs.com/docs/migrating_to_6.html#strictquery-is-removed-and-replaced-by-strict
  mongoose.set('strictQuery', false);
  
  // Define the database URL to connect to.
  const mongoDB = "mongodb://127.0.0.1/my_database";
  
  // Wait for database to connect, logging an error if there is a problem 
  main().catch(err => console.log(err));
  async function main() {
    await mongoose.connect(mongoDB);
  }
  

  25 default menjadi

  // Import the mongoose module
  const mongoose = require("mongoose");
  
  // Set `strictQuery: false` to globally opt into filtering by properties that aren't in the schema
  // Included because it removes preparatory warnings for Mongoose 7.
  // See: https://mongoosejs.com/docs/migrating_to_6.html#strictquery-is-removed-and-replaced-by-strict
  mongoose.set('strictQuery', false);
  
  // Define the database URL to connect to.
  const mongoDB = "mongodb://127.0.0.1/my_database";
  
  // Wait for database to connect, logging an error if there is a problem 
  main().catch(err => console.log(err));
  async function main() {
    await mongoose.connect(mongoDB);
  }
  

  26 (perhatikan bagaimana Anda dapat memanggil fungsi Tanggal saat menyetel tanggal. )

Segala sesuatu yang lain harus familiar dari skema kita sebelumnya

Bukalah. /model/genre. js dan buat skema untuk menyimpan genre (kategori buku, mis. g. apakah itu fiksi atau non-fiksi, romansa atau sejarah militer, dll. )

Definisinya akan sangat mirip dengan model lainnya

• Model harus memiliki

  // Create an instance of model SomeModel
  const awesome_instance = new SomeModel({ name: "awesome" });
  
  // Save the new model instance, passing a callback
  awesome_instance.save((err) => {
    if (err) return handleError(err);
    // saved!
  });
  

  2 SchemaType yang disebut

  // Create an instance of model SomeModel
  const awesome_instance = new SomeModel({ name: "awesome" });
  
  // Save the new model instance, passing a callback
  awesome_instance.save((err) => {
    if (err) return handleError(err);
    // saved!
  });
  

  3 untuk mendeskripsikan genre
• Nama ini wajib diisi dan memiliki antara 3 dan 100 karakter
• Deklarasikan a untuk URL genre, bernama

  // Import the mongoose module
  const mongoose = require("mongoose");
  
  // Set `strictQuery: false` to globally opt into filtering by properties that aren't in the schema
  // Included because it removes preparatory warnings for Mongoose 7.
  // See: https://mongoosejs.com/docs/migrating_to_6.html#strictquery-is-removed-and-replaced-by-strict
  mongoose.set('strictQuery', false);
  
  // Define the database URL to connect to.
  const mongoDB = "mongodb://127.0.0.1/my_database";
  
  // Wait for database to connect, logging an error if there is a problem 
  main().catch(err => console.log(err));
  async function main() {
    await mongoose.connect(mongoDB);
  }
  

  29
• Ekspor modelnya

Itu dia. Kami sekarang memiliki semua model untuk penyiapan situs

Untuk menguji model (dan untuk membuat beberapa buku contoh dan item lain yang dapat kami gunakan di artikel berikutnya), kami sekarang akan menjalankan skrip independen untuk membuat item dari setiap jenis

1. Unduh (atau buat) file yang diisib. js di dalam direktori express-locallibrary-tutorial Anda (setingkat dengan

   // Import the mongoose module
   const mongoose = require("mongoose");
   
   // Set `strictQuery: false` to globally opt into filtering by properties that aren't in the schema
   // Included because it removes preparatory warnings for Mongoose 7.
   // See: https://mongoosejs.com/docs/migrating_to_6.html#strictquery-is-removed-and-replaced-by-strict
   mongoose.set('strictQuery', false);
   
   // Define the database URL to connect to.
   const mongoDB = "mongodb://127.0.0.1/my_database";
   
   // Wait for database to connect, logging an error if there is a problem 
   main().catch(err => console.log(err));
   async function main() {
     await mongoose.connect(mongoDB);
   }
   

   30)

   Catatan. Anda tidak perlu tahu cara kerja ________19______31;

2. Masukkan perintah berikut di root proyek untuk menginstal modul async yang diperlukan oleh skrip (kita akan membahasnya di tutorial selanjutnya)

   // Require Mongoose
   const mongoose = require("mongoose");
   
   // Define a schema
   const Schema = mongoose.Schema;
   
   const SomeModelSchema = new Schema({
     a_string: String,
     a_date: Date,
   });
   

   _4

3. Jalankan skrip menggunakan node di command prompt Anda, meneruskan URL database MongoDB Anda (yang sama dengan yang Anda gantikan placeholder insert_your_database_url_here dengan, di dalam

   // Import the mongoose module
   const mongoose = require("mongoose");
   
   // Set `strictQuery: false` to globally opt into filtering by properties that aren't in the schema
   // Included because it removes preparatory warnings for Mongoose 7.
   // See: https://mongoosejs.com/docs/migrating_to_6.html#strictquery-is-removed-and-replaced-by-strict
   mongoose.set('strictQuery', false);
   
   // Define the database URL to connect to.
   const mongoDB = "mongodb://127.0.0.1/my_database";
   
   // Wait for database to connect, logging an error if there is a problem 
   main().catch(err => console.log(err));
   async function main() {
     await mongoose.connect(mongoDB);
   }
   

   32 sebelumnya)

   // Require Mongoose
   const mongoose = require("mongoose");
   
   // Define a schema
   const Schema = mongoose.Schema;
   
   const SomeModelSchema = new Schema({
     a_string: String,
     a_date: Date,
   });
   

   5

   Catatan. Di Windows Anda perlu membungkus URL basis data di dalam double (""). Pada sistem operasi lain, Anda mungkin memerlukan tanda kutip tunggal (').

4. Skrip harus dijalankan hingga selesai, menampilkan item saat dibuat di terminal

Catatan. Buka database Anda di mongoDB Atlas (di tab Collections). Anda sekarang dapat menelusuri koleksi Buku, Penulis, Genre, dan Instans Buku individual, dan memeriksa dokumen individual

Pada artikel ini, kita telah belajar sedikit tentang database dan ORM pada Node/Express, dan banyak tentang bagaimana skema dan model Mongoose didefinisikan. Kami kemudian menggunakan informasi ini untuk merancang dan mengimplementasikan model

// Require Mongoose
const mongoose = require("mongoose");

// Define a schema
const Schema = mongoose.Schema;

const SomeModelSchema = new Schema({
  a_string: String,
  a_date: Date,
});

const schema = new Schema({
  name: String,
  binary: Buffer,
  living: Boolean,
  updated: { type: Date, default: Date.now() },
  age: { type: Number, min: 18, max: 65, required: true },
  mixed: Schema.Types.Mixed,
  _someId: Schema.Types.ObjectId,
  array: [],
  ofString: [String], // You can also have an array of each of the other types too.
  nested: { stuff: { type: String, lowercase: true, trim: true } },
});

// Define schema
const Schema = mongoose.Schema;

const SomeModelSchema = new Schema({
  a_string: String,
  a_date: Date,
});

// Compile model from schema
const SomeModel = mongoose.model("SomeModel", SomeModelSchema);

// Require Mongoose
const mongoose = require("mongoose");

// Define a schema
const Schema = mongoose.Schema;

const SomeModelSchema = new Schema({
  a_string: String,
  a_date: Date,
});

Terakhir, kami menguji model kami dengan membuat sejumlah instance (menggunakan skrip mandiri). Di artikel selanjutnya kita akan melihat membuat beberapa halaman untuk menampilkan objek-objek ini

Bagaimana cara membuat skema di MongoDB menggunakan node JS tanpa luwak?

Bagaimana cara membuat koleksi di MongoDB dengan node js?

Bagaimana cara membuat koleksi secara manual di MongoDB?

Apakah saya perlu menggunakan luwak dengan MongoDB?