Mongoose kết nối với MongoDB Atlas

Nhân viên thư viện sẽ sử dụng trang web Thư viện địa phương để lưu trữ thông tin về sách và người mượn, trong khi các thành viên thư viện sẽ sử dụng nó để duyệt và tìm kiếm sách, tìm hiểu xem có bất kỳ bản sao nào không, sau đó đặt trước hoặc mượn chúng. Để lưu trữ và truy xuất thông tin hiệu quả, chúng tôi sẽ lưu trữ nó trong cơ sở dữ liệu

Ứng dụng Express có thể sử dụng nhiều cơ sở dữ liệu khác nhau và có một số phương pháp bạn có thể sử dụng để thực hiện các thao tác Tạo, Đọc, Cập nhật và Xóa (CRUD). Hướng dẫn này cung cấp một cái nhìn tổng quan ngắn gọn về một số tùy chọn có sẵn và sau đó tiếp tục hiển thị chi tiết các cơ chế cụ thể được chọn

Các ứng dụng Express có thể sử dụng bất kỳ cơ sở dữ liệu nào được Node hỗ trợ (Bản thân Express không xác định bất kỳ hành vi/yêu cầu bổ sung cụ thể nào để quản lý cơ sở dữ liệu). Có nhiều tùy chọn phổ biến, bao gồm PostgreSQL, MySQL, Redis, SQLite và MongoDB

Khi chọn cơ sở dữ liệu, bạn nên xem xét những thứ như đường cong thời gian để đạt năng suất/học tập, hiệu suất, khả năng sao chép/sao lưu dễ dàng, chi phí, hỗ trợ cộng đồng, v.v. Mặc dù không có cơ sở dữ liệu "tốt nhất" duy nhất, nhưng hầu hết mọi giải pháp phổ biến đều có thể chấp nhận được đối với trang web có quy mô vừa và nhỏ như Thư viện địa phương của chúng tôi

Để biết thêm thông tin về các tùy chọn, hãy xem Tích hợp cơ sở dữ liệu (Tài liệu nhanh)

Có hai cách tiếp cận phổ biến để tương tác với cơ sở dữ liệu

• Sử dụng ngôn ngữ truy vấn riêng của cơ sở dữ liệu (e. g. SQL)
• Sử dụng Mô hình Dữ liệu Đối tượng ("ODM") hoặc Mô hình Quan hệ Đối tượng ("ORM"). ODM/ORM đại diện cho dữ liệu của trang web dưới dạng các đối tượng JavaScript, sau đó được ánh xạ tới cơ sở dữ liệu bên dưới. Một số ORM được gắn với một cơ sở dữ liệu cụ thể, trong khi những ORM khác cung cấp phần phụ trợ không liên quan đến cơ sở dữ liệu

Hiệu suất tốt nhất có thể đạt được bằng cách sử dụng SQL hoặc bất kỳ ngôn ngữ truy vấn nào được cơ sở dữ liệu hỗ trợ. ODM thường chậm hơn vì chúng sử dụng mã dịch để ánh xạ giữa các đối tượng và định dạng cơ sở dữ liệu, định dạng này có thể không sử dụng các truy vấn cơ sở dữ liệu hiệu quả nhất (điều này đặc biệt đúng nếu ODM hỗ trợ các phụ trợ cơ sở dữ liệu khác nhau và phải thỏa hiệp nhiều hơn về cơ sở dữ liệu nào

Lợi ích của việc sử dụng ORM là các lập trình viên có thể tiếp tục suy nghĩ về các đối tượng JavaScript thay vì ngữ nghĩa của cơ sở dữ liệu — điều này đặc biệt đúng nếu bạn cần làm việc với các cơ sở dữ liệu khác nhau (trên cùng một trang web hoặc các trang web khác nhau). Họ cũng cung cấp một nơi rõ ràng để thực hiện xác thực dữ liệu

Ghi chú. Sử dụng ODM/ORM thường dẫn đến chi phí phát triển và bảo trì thấp hơn. Trừ khi bạn rất quen thuộc với ngôn ngữ truy vấn gốc hoặc hiệu suất là tối quan trọng, bạn nên cân nhắc sử dụng ODM

Có nhiều giải pháp ODM/ORM có sẵn trên trang web quản lý gói npm (kiểm tra các thẻ odm và orm để biết một tập hợp con. )

Một vài giải pháp phổ biến tại thời điểm viết là

• cầy mangut. Mongoose là một công cụ mô hình hóa đối tượng MongoDB được thiết kế để hoạt động trong môi trường không đồng bộ
• Dòng nước. Một ORM được trích xuất từ ​​khung web Sails dựa trên Express. Nó cung cấp một API thống nhất để truy cập nhiều cơ sở dữ liệu khác nhau, bao gồm Redis, MySQL, LDAP, MongoDB và Postgres
• Giá sách. Có cả giao diện gọi lại dựa trên lời hứa và truyền thống, cung cấp hỗ trợ giao dịch, tải quan hệ háo hức/lồng nhau háo hức, liên kết đa hình và hỗ trợ quan hệ một-một, một-nhiều và nhiều-nhiều. Hoạt động với PostgreSQL, MySQL và SQLite3
• Sự phản đối. Làm cho việc sử dụng toàn bộ sức mạnh của SQL và công cụ cơ sở dữ liệu cơ bản trở nên dễ dàng nhất có thể (hỗ trợ SQLite3, Postgres và MySQL)
• Sequelize là một ORM dựa trên lời hứa cho Node. js và io. js. Nó hỗ trợ các phương ngữ PostgreSQL, MySQL, MariaDB, SQLite và MSSQL và có tính năng hỗ trợ giao dịch vững chắc, quan hệ, sao chép đọc và hơn thế nữa
• Node ORM2 là Trình quản lý quan hệ đối tượng cho NodeJS. Nó hỗ trợ MySQL, SQLite và Progress, giúp làm việc với cơ sở dữ liệu bằng phương pháp hướng đối tượng
• GraphQL. Chủ yếu là ngôn ngữ truy vấn cho các API an toàn, GraphQL rất phổ biến và có sẵn các tính năng để đọc dữ liệu từ cơ sở dữ liệu

Theo nguyên tắc chung, bạn nên xem xét cả các tính năng được cung cấp và "hoạt động cộng đồng" (tải xuống, đóng góp, báo cáo lỗi, chất lượng tài liệu, v.v. ) khi lựa chọn giải pháp. Tại thời điểm viết bài, Mongoose cho đến nay là ODM phổ biến nhất và là một lựa chọn hợp lý nếu bạn đang sử dụng MongoDB cho cơ sở dữ liệu của mình

Đối với ví dụ về Thư viện cục bộ (và phần còn lại của chủ đề này), chúng tôi sẽ sử dụng Mongoose ODM để truy cập dữ liệu thư viện của chúng tôi. Mongoose hoạt động như một giao diện người dùng cho MongoDB, một cơ sở dữ liệu NoSQL nguồn mở sử dụng mô hình dữ liệu hướng tài liệu. Một "bộ sưu tập" các "tài liệu" trong cơ sở dữ liệu MongoDB tương tự như một "bảng" các "hàng" trong cơ sở dữ liệu quan hệ

Sự kết hợp giữa ODM và cơ sở dữ liệu này cực kỳ phổ biến trong cộng đồng Node, một phần vì hệ thống truy vấn và lưu trữ tài liệu trông rất giống JSON và do đó quen thuộc với các nhà phát triển JavaScript

Ghi chú. Bạn không cần phải biết MongoDB để sử dụng Mongoose, mặc dù các phần của tài liệu Mongoose sẽ dễ sử dụng và dễ hiểu hơn nếu bạn đã quen thuộc với MongoDB

Phần còn lại của hướng dẫn này chỉ ra cách xác định và truy cập lược đồ và mô hình Mongoose cho ví dụ về trang web LocalLibrary

Trước khi bạn tham gia và bắt đầu mã hóa các mô hình, bạn nên dành vài phút để suy nghĩ về dữ liệu nào chúng ta cần lưu trữ và mối quan hệ giữa các đối tượng khác nhau

Chúng tôi biết rằng chúng tôi cần lưu trữ thông tin về sách (tên sách, tóm tắt, tác giả, thể loại, ISBN) và rằng chúng tôi có thể có sẵn nhiều bản sao (với id duy nhất trên toàn cầu, trạng thái sẵn có, v.v. ). Chúng tôi có thể cần lưu trữ nhiều thông tin về tác giả hơn là chỉ tên của họ và có thể có nhiều tác giả có cùng tên hoặc tên tương tự. Chúng tôi muốn có thể sắp xếp thông tin dựa trên tên sách, tác giả, thể loại và danh mục

Khi thiết kế các mô hình của bạn, bạn nên có các mô hình riêng biệt cho mọi "đối tượng" (một nhóm thông tin liên quan). Trong trường hợp này, một số ứng cử viên rõ ràng cho các mô hình này là sách, thực thể sách và tác giả.

Bạn cũng có thể muốn sử dụng các mô hình để thể hiện các tùy chọn trong danh sách lựa chọn (e. g. như danh sách lựa chọn thả xuống), thay vì mã hóa cứng các lựa chọn vào chính trang web — điều này được khuyến nghị khi tất cả các tùy chọn không được biết trước hoặc có thể thay đổi. Một ví dụ điển hình là một thể loại (e. g. tưởng tượng, khoa học viễn tưởng, vv. )

Khi chúng tôi đã quyết định về các mô hình và lĩnh vực của mình, chúng tôi cần suy nghĩ về mối quan hệ giữa chúng

Với ý nghĩ đó, sơ đồ liên kết UML bên dưới hiển thị các mô hình mà chúng ta sẽ xác định trong trường hợp này (dưới dạng hộp). Như đã thảo luận ở trên, chúng tôi đã tạo các mô hình cho cuốn sách (các chi tiết chung của cuốn sách), phiên bản sách (trạng thái của các bản sao cụ thể của cuốn sách có sẵn trong hệ thống) và tác giả. Chúng tôi cũng đã quyết định có một mô hình cho thể loại này để các giá trị có thể được tạo ra một cách linh hoạt. Chúng tôi đã quyết định không có mô hình cho

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

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

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

Sơ đồ cũng cho thấy mối quan hệ giữa các mô hình, bao gồm cả bội số của chúng. Các bội số là các số trên sơ đồ hiển thị các số (tối đa và tối thiểu) của mỗi mô hình có thể có trong mối quan hệ. Ví dụ: đường kết nối giữa các hộp cho thấy

// 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,
});

Ghi chú. Như đã thảo luận trong phần dưới đây của chúng tôi, tốt hơn là nên có trường xác định mối quan hệ giữa các tài liệu/mô hình chỉ trong một mô hình (bạn vẫn có thể tìm thấy mối quan hệ ngược lại bằng cách tìm kiếm

// 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,
});

// 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,
});

Ghi chú. Phần tiếp theo cung cấp kiến ​​thức cơ bản giải thích cách xác định và sử dụng các mô hình. Khi bạn đọc nó, hãy cân nhắc cách chúng ta sẽ xây dựng từng mô hình trong sơ đồ trên

Phần này cung cấp tổng quan về cách kết nối Mongoose với cơ sở dữ liệu MongoDB, cách xác định lược đồ và mô hình cũng như cách thực hiện các truy vấn cơ bản

Ghi chú. Đoạn mồi này bị ảnh hưởng nặng nề bởi khởi động nhanh Mongoose trên npm và tài liệu chính thức

Mongoose được cài đặt trong dự án của bạn (gói. json) giống như bất kỳ phần phụ thuộc nào khác — sử dụng npm. Để cài đặt nó, hãy sử dụng lệnh sau trong thư mục dự án của bạn

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

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

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

Cài đặt Mongoose thêm tất cả các phụ thuộc của nó, bao gồm trình điều khiển cơ sở dữ liệu MongoDB, nhưng bản thân nó không cài đặt MongoDB. Nếu bạn muốn cài đặt máy chủ MongoDB thì bạn có thể tải xuống trình cài đặt từ đây cho các hệ điều hành khác nhau và cài đặt cục bộ. Bạn cũng có thể sử dụng các phiên bản MongoDB dựa trên đám mây

Ghi chú. Đối với hướng dẫn này, chúng tôi sẽ sử dụng cơ sở dữ liệu dựa trên đám mây MongoDB Atlas dưới dạng tầng dịch vụ miễn phí để cung cấp cơ sở dữ liệu. Điều này phù hợp để phát triển và có ý nghĩa đối với hướng dẫn vì nó làm cho hệ điều hành "cài đặt" trở nên độc lập (cơ sở dữ liệu dưới dạng dịch vụ cũng là một cách tiếp cận bạn có thể sử dụng cho cơ sở dữ liệu sản xuất của mình)

Mongoose yêu cầu kết nối với cơ sở dữ liệu MongoDB. Bạn có thể

// 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,
});

Bạn có thể lấy đối tượng

// 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,
});

Ghi chú. Nếu bạn cần tạo các kết nối bổ sung, bạn có thể sử dụng

// 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,
});

Các mô hình được xác định bằng giao diện

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

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

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

Các lược đồ sau đó được "biên dịch" thành các mô hình bằng phương pháp

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

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

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

Ghi chú. Mỗi mô hình ánh xạ tới một tập hợp các tài liệu trong cơ sở dữ liệu MongoDB. Các tài liệu sẽ chứa các trường/loại lược đồ được xác định trong mô hình

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

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

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

Xác định lược đồ

Đoạn mã dưới đây cho thấy cách bạn có thể định nghĩa một lược đồ đơn giản. Trước tiên, bạn

// 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,
});

Trong trường hợp trên, chúng tôi chỉ có hai trường, một chuỗi và một ngày. Trong các phần tiếp theo, chúng tôi sẽ hiển thị một số loại trường khác, xác thực và các phương thức khác

Tạo một mô hình

Các mô hình được tạo từ các lược đồ bằng phương pháp

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

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

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

________số 8

Đối số đầu tiên là tên riêng của bộ sưu tập sẽ được tạo cho mô hình của bạn (Mongoose sẽ tạo bộ sưu tập cơ sở dữ liệu cho mô hình SomeModel ở trên) và đối số thứ hai là lược đồ bạn muốn sử dụng để tạo mô hình

Ghi chú. Khi bạn đã xác định các lớp mô hình của mình, bạn có thể sử dụng chúng để tạo, cập nhật hoặc xóa bản ghi và chạy các truy vấn để lấy tất cả bản ghi hoặc tập con cụ thể của bản ghi. Chúng tôi sẽ chỉ cho bạn cách thực hiện việc này trong phần này và khi chúng tôi tạo chế độ xem của mình

Các loại lược đồ (trường)

Một lược đồ có thể có số lượng trường tùy ý — mỗi lược đồ đại diện cho một trường trong tài liệu được lưu trữ trong MongoDB. Một lược đồ ví dụ hiển thị nhiều loại trường phổ biến và cách chúng được khai báo được hiển thị bên dưới

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

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

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

Hầu hết các SchemaTypes (mô tả sau "type. " hoặc sau tên trường) là tự giải thích. Các trường hợp ngoại lệ là

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

  65. Đại diện cho các trường hợp cụ thể của một mô hình trong cơ sở dữ liệu. Ví dụ: một cuốn sách có thể sử dụng điều này để đại diện cho đối tượng tác giả của nó. Điều này thực sự sẽ chứa ID duy nhất (

  // 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) cho đối tượng được chỉ định. Chúng ta có thể sử dụng phương pháp

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

  67 để lấy thông tin liên quan khi cần
• Một loại lược đồ tùy ý

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

  69. Một mảng các mặt hàng. Bạn có thể thực hiện các thao tác mảng JavaScript trên các mô hình này (push, pop, unshift, v.v. ). Các ví dụ trên hiển thị một mảng các đối tượng không có loại được chỉ định và một mảng gồm các đối tượng

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

  80, nhưng bạn có thể có một mảng gồm bất kỳ loại đối tượng nào

Mã này cũng hiển thị cả hai cách khai báo trường

• Tên trường và nhập dưới dạng cặp khóa-giá trị (i. e. như đã làm với các trường

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

  81,

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

  82 và

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

  83)
• Tên trường theo sau là một đối tượng xác định

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

  84 và bất kỳ tùy chọn nào khác cho trường. Các tùy chọn bao gồm những thứ như
  • giá trị mặc định
  • trình xác thực tích hợp (e. g. giá trị tối đa/tối thiểu) và các chức năng xác thực tùy chỉnh
  • Trường có bắt buộc không
  • Liệu các trường

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

    80 có nên tự động được đặt thành chữ thường, chữ hoa hay được cắt xén hay không (e. g.

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

    86)

Để biết thêm thông tin về các tùy chọn, hãy xem SchemaTypes (Mongoose docs)

Thẩm định

Mongoose cung cấp trình xác thực tùy chỉnh và tích hợp cũng như trình xác thực đồng bộ và không đồng bộ. Nó cho phép bạn chỉ định cả phạm vi giá trị được chấp nhận và thông báo lỗi cho lỗi xác thực trong mọi trường hợp

Trình xác thực tích hợp bao gồm

• Tất cả các SchemaType đều có trình xác thực tích hợp. Điều này được sử dụng để chỉ định xem trường có phải được cung cấp để lưu tài liệu hay không
• có và trình xác nhận
• có
  • chỉ định tập hợp các giá trị được phép cho trường
  • chỉ định một biểu thức chính quy mà chuỗi phải khớp
  • và cho chuỗi

Ví dụ bên dưới (được sửa đổi một chút từ tài liệu Mongoose) cho thấy cách bạn có thể chỉ định một số loại trình xác thực và thông báo lỗi

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

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

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

Để biết thông tin đầy đủ về xác thực trường, hãy xem Xác thực (tài liệu Mongoose)

tài sản ảo

Thuộc tính ảo là thuộc tính tài liệu mà bạn có thể lấy và đặt nhưng không được duy trì trong MongoDB. Các getter hữu ích cho việc định dạng hoặc kết hợp các trường, trong khi các setter hữu ích cho việc tách một giá trị thành nhiều giá trị để lưu trữ. Ví dụ trong tài liệu xây dựng (và giải cấu trúc) một thuộc tính ảo tên đầy đủ từ trường họ và tên, cách này dễ dàng và rõ ràng hơn so với việc xây dựng tên đầy đủ mỗi khi một tên được sử dụng trong mẫu

Ghi chú. Chúng tôi sẽ sử dụng một thuộc tính ảo trong thư viện để xác định một URL duy nhất cho mỗi bản ghi mô hình bằng đường dẫn và giá trị

// 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);

Để biết thêm thông tin, xem (Mongoose documentation)

Các phương thức và trợ giúp truy vấn

Một lược đồ cũng có thể có , , và. Phương thức thể hiện và phương thức tĩnh tương tự nhau, nhưng có sự khác biệt rõ ràng là phương thức thể hiện được liên kết với một bản ghi cụ thể và có quyền truy cập vào đối tượng hiện tại. Trình trợ giúp truy vấn cho phép bạn mở rộng API trình tạo truy vấn có thể xâu chuỗi của cầy mangut (ví dụ: cho phép bạn thêm truy vấn "byName" ngoài các phương thức

// 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,
});

Khi bạn đã tạo một lược đồ, bạn có thể sử dụng nó để tạo các mô hình. Mô hình đại diện cho một tập hợp các tài liệu trong cơ sở dữ liệu mà bạn có thể tìm kiếm, trong khi các phiên bản của mô hình đại diện cho các tài liệu riêng lẻ mà bạn có thể lưu và truy xuất

Chúng tôi cung cấp một cái nhìn tổng quan ngắn gọn dưới đây. Để biết thêm thông tin xem. Mô hình (tài liệu Mongoose)

Tạo và sửa đổi tài liệu

Để tạo một bản ghi, bạn có thể xác định một phiên bản của mô hình và sau đó gọi

// 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,
});

Việc tạo bản ghi (cùng với cập nhật, xóa và truy vấn) là các hoạt động không đồng bộ — bạn cung cấp lệnh gọi lại được gọi khi hoạt động hoàn tất. API sử dụng quy ước đối số lỗi đầu tiên, vì vậy đối số đầu tiên cho lệnh gọi lại sẽ luôn là một giá trị lỗi (hoặc null). Nếu API trả về một số kết quả, điều này sẽ được cung cấp làm đối số thứ hai

Bạn cũng có thể sử dụng

// 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,
});

Mọi kiểu máy đều có một kết nối được liên kết (đây sẽ là kết nối mặc định khi bạn sử dụng

// 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,
});

Bạn có thể truy cập các trường trong bản ghi mới này bằng cú pháp dấu chấm và thay đổi các giá trị. Bạn phải gọi

// 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,
});

Tìm kiếm hồ sơ

Bạn có thể tìm kiếm các bản ghi bằng các phương thức truy vấn, chỉ định các điều kiện truy vấn dưới dạng tài liệu JSON. Đoạn mã dưới đây cho thấy cách bạn có thể tìm thấy tất cả các vận động viên trong cơ sở dữ liệu chơi quần vợt, chỉ trả lại các trường cho tên và tuổi của vận động viên. Ở đây chúng tôi chỉ xác định một trường phù hợp (thể thao) nhưng bạn có thể thêm nhiều tiêu chí hơn, chỉ định tiêu chí biểu thức chính quy hoặc xóa hoàn toàn các điều kiện để trả về tất cả các vận động viên

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

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

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

Nếu bạn chỉ định một cuộc gọi lại, như được hiển thị ở trên, truy vấn sẽ thực thi ngay lập tức. Cuộc gọi lại sẽ được gọi khi tìm kiếm hoàn tất

Ghi chú. Tất cả các cuộc gọi lại trong Mongoose đều sử dụng mẫu

// 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,
});

Ghi chú. Điều quan trọng cần nhớ là không tìm thấy bất kỳ kết quả nào không phải là lỗi đối với tìm kiếm — nhưng đó có thể là trường hợp không thành công trong ngữ cảnh ứng dụng của bạn. Nếu ứng dụng của bạn mong muốn một tìm kiếm tìm thấy một giá trị, bạn có thể kiểm tra kết quả trong hàm gọi lại (

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

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

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

Nếu bạn không chỉ định gọi lại thì API sẽ trả về một biến loại. Bạn có thể sử dụng đối tượng truy vấn này để xây dựng truy vấn của mình và sau đó thực hiện truy vấn đó (có gọi lại) sau đó bằng phương thức

// 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,
});

Ở trên, chúng tôi đã xác định các điều kiện truy vấn trong phương thức

// 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,
});

Phương thức lấy tất cả các bản ghi phù hợp, nhưng thường thì bạn chỉ muốn lấy một bản ghi phù hợp. Các phương pháp sau truy vấn cho một bản ghi

• Tìm tài liệu có

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

  87 được chỉ định (mỗi tài liệu có một

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

  87 duy nhất)
• Tìm một tài liệu phù hợp với tiêu chí đã chỉ định
• , , ,. Tìm một tài liệu duy nhất theo

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

  87 hoặc tiêu chí và cập nhật hoặc xóa tài liệu đó. Đây là những chức năng thuận tiện hữu ích để cập nhật và xóa bản ghi

Ghi chú. Ngoài ra còn có một phương pháp mà bạn có thể sử dụng để lấy số lượng mục phù hợp với điều kiện. Điều này hữu ích nếu bạn muốn thực hiện đếm mà không thực sự tìm nạp các bản ghi

Còn rất nhiều điều bạn có thể làm với các truy vấn. Để biết thêm thông tin xem. Truy vấn (tài liệu Mongoose)

Làm việc với các tài liệu liên quan - dân số

Bạn có thể tạo tham chiếu từ một tài liệu/phiên bản mô hình này sang một tài liệu/mô hình khác bằng cách sử dụng trường lược đồ

// 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,
});

Ví dụ: lược đồ sau xác định tác giả và câu chuyện. Mỗi tác giả có thể có nhiều câu chuyện mà chúng tôi biểu diễn dưới dạng một mảng của

// 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,
});

Chúng tôi có thể lưu các tham chiếu của mình vào tài liệu liên quan bằng cách gán giá trị

// 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,
});

Tài liệu câu chuyện của chúng tôi hiện có một tác giả được tham chiếu bởi ID của tài liệu tác giả. Để lấy thông tin tác giả trong kết quả truyện ta sử dụng

// 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,
});

Ghi chú. Những độc giả tinh ý sẽ lưu ý rằng chúng tôi đã thêm một tác giả vào câu chuyện của mình, nhưng chúng tôi đã không làm bất cứ điều gì để thêm câu chuyện của mình vào mảng

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

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

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

Cách tốt hơn là lấy

// 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,
});

Đây gần như là mọi thứ bạn cần biết về cách làm việc với các mục liên quan cho hướng dẫn này. Để biết thêm thông tin chi tiết, xem Dân số (Mongoose docs)

Mặc dù bạn có thể tạo các lược đồ và mô hình bằng cách sử dụng bất kỳ cấu trúc tệp nào bạn thích, nhưng chúng tôi thực sự khuyên bạn nên xác định từng lược đồ mô hình trong mô-đun (tệp) riêng của nó, sau đó xuất phương thức để tạo mô hình. Điều này được hiển thị dưới đây

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

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

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

Sau đó, bạn có thể yêu cầu và sử dụng mô hình ngay lập tức trong các tệp khác. Dưới đây chúng tôi chỉ ra cách bạn có thể sử dụng nó để lấy tất cả các phiên bản của mô hình

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

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

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

Bây giờ chúng ta đã hiểu điều gì đó về những gì Mongoose có thể làm và cách chúng ta muốn thiết kế các mô hình của mình, đã đến lúc bắt đầu làm việc trên trang web LocalLibrary. Điều đầu tiên chúng tôi muốn làm là thiết lập cơ sở dữ liệu MongoDB mà chúng tôi có thể sử dụng để lưu trữ dữ liệu thư viện của mình

Đối với hướng dẫn này, chúng tôi sẽ sử dụng cơ sở dữ liệu hộp cát được lưu trữ trên đám mây MongoDB Atlas. Tầng cơ sở dữ liệu này không được coi là phù hợp cho các trang web sản xuất vì nó không có dự phòng, nhưng nó rất tốt cho việc phát triển và tạo mẫu. Chúng tôi đang sử dụng nó ở đây vì nó miễn phí và dễ cài đặt, và vì MongoDB Atlas là cơ sở dữ liệu phổ biến với tư cách là nhà cung cấp dịch vụ mà bạn có thể chọn một cách hợp lý cho cơ sở dữ liệu sản xuất của mình (các lựa chọn phổ biến khác tại thời điểm viết bao gồm Compose, ScaleGrid

Ghi chú. Nếu muốn, bạn có thể thiết lập cục bộ cơ sở dữ liệu MongoDb bằng cách tải xuống và cài đặt các tệp nhị phân thích hợp cho hệ thống của mình. Phần còn lại của hướng dẫn trong bài viết này sẽ tương tự, ngoại trừ URL cơ sở dữ liệu bạn sẽ chỉ định khi kết nối. Trong Hướng dẫn cấp tốc Phần 7. Triển khai hướng dẫn Sản xuất, chúng tôi lưu trữ cả ứng dụng và cơ sở dữ liệu trên Đường sắt, nhưng chúng tôi cũng có thể sử dụng cơ sở dữ liệu trên MongoDB Atlas

Trước tiên, bạn cần tạo một tài khoản với MongoDB Atlas (tài khoản này miễn phí và chỉ yêu cầu bạn nhập các chi tiết liên hệ cơ bản và xác nhận các điều khoản dịch vụ của họ)

Sau khi đăng nhập, bạn sẽ được đưa đến màn hình chính

1. Nhấp vào nút Xây dựng cơ sở dữ liệu trong phần Triển khai cơ sở dữ liệu.
   
2. Thao tác này sẽ mở màn hình Triển khai cơ sở dữ liệu đám mây. Nhấp vào nút Tạo trong tùy chọn Triển khai được chia sẻ.
3. Thao tác này sẽ mở màn hình Tạo cụm được chia sẻ.
   • Chọn bất kỳ nhà cung cấp nào từ phần Nhà cung cấp đám mây & Khu vực. Các khu vực khác nhau cung cấp các nhà cung cấp khác nhau.
   • Cấp cụm và Cài đặt bổ sung không cần phải thay đổi. Bạn có thể thay đổi tên Cụm của mình trong Tên cụm. Chúng tôi đang đặt tên nó là

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

     906 cho hướng dẫn này
   • Nhấp vào nút Tạo cụm (việc tạo cụm sẽ mất vài phút)
4. Thao tác này sẽ mở phần Bắt đầu nhanh về bảo mật.
   • Nhập tên người dùng và mật khẩu. Hãy nhớ sao chép và lưu trữ thông tin đăng nhập một cách an toàn vì chúng tôi sẽ cần chúng sau này. Nhấp vào nút Tạo người dùng.

     Ghi chú. Tránh sử dụng các ký tự đặc biệt trong mật khẩu người dùng MongoDB của bạn vì cầy mangut có thể không phân tích chuỗi kết nối đúng cách

   • Nhập

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

     907 vào trường Địa chỉ IP. Điều này cho MongoDB biết rằng chúng tôi muốn cho phép truy cập từ mọi nơi. Nhấp vào nút Thêm mục nhập

     Ghi chú. Cách tốt nhất là hạn chế các địa chỉ IP có thể kết nối với cơ sở dữ liệu của bạn và các tài nguyên khác. Ở đây chúng tôi cho phép kết nối từ mọi nơi vì chúng tôi không biết yêu cầu sẽ đến từ đâu sau khi triển khai

   • Nhấp vào nút Kết thúc và Đóng
5. Thao tác này sẽ mở màn hình sau. Nhấp vào nút Chuyển đến cơ sở dữ liệu.
6. Bạn sẽ quay lại màn hình Triển khai cơ sở dữ liệu. Nhấp vào nút Duyệt bộ sưu tập.
7. Thao tác này sẽ mở phần Bộ sưu tập. Nhấp vào nút Thêm dữ liệu của riêng tôi.
8. Thao tác này sẽ mở màn hình Tạo cơ sở dữ liệu.
   • Nhập tên cho cơ sở dữ liệu mới là

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

     908.
   • Nhập tên của bộ sưu tập là

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

     909
   • Click nút Create để tạo cơ sở dữ liệu
9. Bạn sẽ quay lại màn hình Bộ sưu tập với cơ sở dữ liệu đã tạo.
   • Nhấp vào tab Tổng quan để quay lại tổng quan về cụm.
10. Từ màn hình Tổng quan về Cluster0, nhấp vào nút Kết nối.
11. Thao tác này sẽ mở màn hình Kết nối với cụm. Nhấp vào tùy chọn Kết nối ứng dụng của bạn.
12. Bây giờ bạn sẽ thấy màn hình Kết nối.
    • Chọn phiên bản và trình điều khiển Node như hình minh họa.
    • Nhấp vào biểu tượng Sao chép để sao chép chuỗi kết nối
    • Dán cái này vào trình soạn thảo văn bản cục bộ của bạn
    • Cập nhật tên người dùng và mật khẩu bằng mật khẩu người dùng của bạn
    • Chèn tên cơ sở dữ liệu "local_library" vào đường dẫn trước các tùy chọn (

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

      910)
    • Lưu tệp chứa chuỗi này ở nơi an toàn

Bây giờ bạn đã tạo cơ sở dữ liệu và có một URL (có tên người dùng và mật khẩu) có thể được sử dụng để truy cập cơ sở dữ liệu đó. Điều này sẽ trông giống như.

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

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

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

Mở một dấu nhắc lệnh và điều hướng đến thư mục nơi bạn đã tạo trang web Thư viện cục bộ bộ xương của mình. Nhập lệnh sau để cài đặt Mongoose (và các phụ thuộc của nó) và thêm nó vào gói của bạn. json, trừ khi bạn đã làm như vậy khi đọc phần trên

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

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

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

Mở chương trình. js (trong thư mục gốc của dự án của bạn) và sao chép văn bản bên dưới nơi bạn khai báo đối tượng ứng dụng Express (sau dòng

// 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,
});

Như đã thảo luận, mã này tạo kết nối mặc định tới cơ sở dữ liệu và liên kết với sự kiện lỗi (do đó lỗi sẽ được in ra bảng điều khiển)

Chúng tôi sẽ xác định một mô-đun riêng cho từng mô hình, như. Bắt đầu bằng cách tạo một thư mục cho các mô hình của chúng tôi trong thư mục gốc của dự án (/models) và sau đó tạo các tệp riêng cho từng mô hình

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

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

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

Sao chép mã lược đồ

// 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,
});

Chúng tôi cũng đã khai báo một cho AuthorSchema có tên là "url" trả về URL tuyệt đối cần thiết để lấy một phiên bản cụ thể của mô hình — chúng tôi sẽ sử dụng thuộc tính này trong các mẫu của mình bất cứ khi nào chúng tôi cần lấy liên kết đến một tác giả cụ thể

Ghi chú. Khai báo các URL của chúng tôi dưới dạng ảo trong lược đồ là một ý tưởng hay vì sau đó URL cho một mục chỉ cần được thay đổi ở một nơi. Tại thời điểm này, một liên kết sử dụng URL này sẽ không hoạt động vì chúng tôi không có bất kỳ mã xử lý tuyến đường nào cho các phiên bản mô hình riêng lẻ. Chúng tôi sẽ thiết lập chúng trong một bài viết sau

Khi kết thúc mô-đun, chúng tôi xuất mô hình

Sao chép mã lược đồ

// 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,
});

Sự khác biệt chính ở đây là chúng tôi đã tạo hai tham chiếu đến các mô hình khác

• tác giả là một tham chiếu đến một đối tượng mô hình

  // 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 duy nhất và được yêu cầu
• thể loại là một tham chiếu đến một mảng các đối tượng mô hình

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

  8. Chúng tôi chưa khai báo đối tượng này

Cuối cùng, sao chép mã lược đồ

// 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,
});

Những điều mới chúng tôi hiển thị ở đây là các tùy chọn trường

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

  921. Điều này cho phép chúng tôi đặt các giá trị được phép của một chuỗi. Trong trường hợp này, chúng tôi sử dụng nó để chỉ định trạng thái sẵn có của sách (sử dụng enum có nghĩa là chúng tôi có thể ngăn lỗi chính tả và các giá trị tùy ý cho trạng thái của chúng tôi)

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

  922. Chúng tôi sử dụng mặc định để đặt trạng thái mặc định cho các trường hợp đặt lịch mới được tạo thành bảo trì và ngày

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

  923 mặc định thành

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

  924 (lưu ý cách bạn có thể gọi hàm Date khi đặt ngày. )

Mọi thứ khác nên quen thuộc với lược đồ trước của chúng tôi

mở của bạn. /mô hình/thể loại. js và tạo một lược đồ để lưu trữ các thể loại (danh mục sách, e. g. cho dù đó là tiểu thuyết hay phi hư cấu, lãng mạn hay lịch sử quân sự, v.v. )

Định nghĩa sẽ rất giống với các mô hình khác

• Mô hình nên có một loại lược đồ

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

  80 được gọi là

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

  81 để mô tả thể loại
• Tên này phải được yêu cầu và có từ 3 đến 100 ký tự
• Khai báo a cho URL của thể loại, tên là

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

  927
• Xuất mô hình

Đó là nó. Bây giờ chúng tôi có tất cả các mô hình cho trang web được thiết lập

Để kiểm tra các mô hình (và để tạo một số sách ví dụ và các mục khác mà chúng ta có thể sử dụng trong các bài viết tiếp theo của mình), bây giờ chúng ta sẽ chạy một tập lệnh độc lập để tạo các mục của từng loại

1. Tải xuống (hoặc tạo) tệp đã điềnb. js bên trong thư mục express-locallibrary-tutorial của bạn (cùng cấp với

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

   928)

   Ghi chú. Bạn không cần biết cách hoạt động của

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

   929;

2. Nhập các lệnh sau vào thư mục gốc của dự án để cài đặt mô-đun async theo yêu cầu của tập lệnh (chúng ta sẽ thảo luận điều này trong các hướng dẫn sau)

   // 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. Chạy tập lệnh bằng cách sử dụng nút trong dấu nhắc lệnh của bạn, chuyển vào URL của cơ sở dữ liệu MongoDB của bạn (chính là URL mà bạn đã thay thế trình giữ chỗ insert_your_database_url_here bằng, bên trong

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

   930 trước đó)

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

   5

   Ghi chú. Trên một số hệ điều hành/thiết bị đầu cuối, bạn có thể cần bọc URL cơ sở dữ liệu bên trong dấu ngoặc kép (") hoặc dấu ngoặc đơn (')

4. Tập lệnh sẽ chạy cho đến khi hoàn thành, hiển thị các mục khi nó tạo chúng trong thiết bị đầu cuối

Ghi chú. Chuyển đến cơ sở dữ liệu của bạn trên mongoDB Atlas (trong tab Bộ sưu tập). Giờ đây, bạn có thể đi sâu vào các bộ sưu tập Sách, Tác giả, Thể loại và Phiên bản sách riêng lẻ cũng như xem các tài liệu riêng lẻ

Trong bài viết này, chúng ta đã tìm hiểu một chút về cơ sở dữ liệu và ORM trên Node/Express, cũng như rất nhiều điều về cách định nghĩa lược đồ và mô hình Mongoose. Sau đó, chúng tôi đã sử dụng thông tin này để thiết kế và triển khai các mô hình

// 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,
});

Cuối cùng, chúng tôi đã thử nghiệm các mô hình của mình bằng cách tạo một số phiên bản (sử dụng tập lệnh độc lập). Trong bài viết tiếp theo, chúng ta sẽ xem xét việc tạo một số trang để hiển thị các đối tượng này

Cầy mangut có thể kết nối với MongoDB Atlas không?

Làm thế nào để sử dụng Atlas với cầy mangut?

Làm cách nào để kết nối với cơ sở dữ liệu MongoDB Atlas?

Làm cách nào để kết nối MongoDB Atlas bằng Python?