mongoose

พังพอน

Mongoose เป็นเครื่องมือสร้างแบบจำลองวัตถุ MongoDB ที่ออกแบบมาเพื่อทำงานในสภาพแวดล้อมแบบอะซิงโครนัส Mongoose รองรับ Node.js และ Deno (อัลฟา)

เอกสารประกอบ

เว็บไซต์เอกสารอย่างเป็นทางการคือ mongoosejs.com

Mongoose 8.0.0 เปิดตัวเมื่อวันที่ 31 ตุลาคม 2023 คุณสามารถดูรายละเอียดเพิ่มเติมเกี่ยวกับการเปลี่ยนแปลงที่ทำลายล้างแบบย้อนหลังใน 8.0.0 ได้ในเว็บไซต์เอกสารของเรา

สนับสนุน

• กองล้น
• รายงานข้อผิดพลาด
• ช่องพังพอนหย่อน
• ฟอรั่มช่วยเหลือ
• รองรับ MongoDB

ปลั๊กอิน

ตรวจสอบไซต์ค้นหาปลั๊กอินเพื่อดูโมดูลที่เกี่ยวข้องหลายร้อยโมดูลจากชุมชน จากนั้น เรียนรู้วิธีเขียนปลั๊กอินของคุณเองจากเอกสารหรือโพสต์ในบล็อกนี้

ผู้ร่วมให้ข้อมูล

ยินดีต้อนรับคำขอดึงเสมอ! โปรดยึดคำขอดึงกับสาขา master และปฏิบัติตามคำแนะนำที่สนับสนุน

หากคำขอดึงของคุณทำให้เอกสารเปลี่ยนแปลง โปรด อย่า แก้ไขไฟล์ .html ใดๆ ไฟล์ .html เป็นโค้ดที่คอมไพล์แล้ว ดังนั้นโปรดทำการเปลี่ยนแปลงใน docs/*.pug , lib/*.js หรือ test/docs/*.js

ดูผู้มีส่วนร่วมทั้งหมด 400+ คน

การติดตั้ง

ขั้นแรกให้ติดตั้ง Node.js และ MongoDB แล้ว:

npm install mongoose

Mongoose 6.8.0 ยังรองรับอัลฟ่าสำหรับ Deno ด้วย

กำลังนำเข้า

 // Using Node.js `require()`
const mongoose = require ( 'mongoose' ) ;

// Using ES6 imports
import mongoose from 'mongoose' ;

หรือใช้ createRequire() ของ Deno เพื่อรองรับ CommonJS ดังต่อไปนี้

 import { createRequire } from 'https://deno.land/[email protected]/node/module.ts' ;
const require = createRequire ( import . meta . url ) ;

const mongoose = require ( 'mongoose' ) ;

mongoose . connect ( 'mongodb://127.0.0.1:27017/test' )
  . then ( ( ) => console . log ( 'Connected!' ) ) ;

จากนั้นคุณสามารถเรียกใช้สคริปต์ข้างต้นได้โดยใช้สิ่งต่อไปนี้

deno run --allow-net --allow-read --allow-sys --allow-env mongoose-test.js

พังพอนสำหรับองค์กร

มีให้เป็นส่วนหนึ่งของการสมัครสมาชิก Tidelift

ผู้ดูแล mongoose และแพ็คเกจอื่น ๆ นับพันกำลังทำงานร่วมกับ Tidelift เพื่อให้การสนับสนุนเชิงพาณิชย์และการบำรุงรักษาสำหรับการพึ่งพาโอเพ่นซอร์สที่คุณใช้ในการสร้างแอปพลิเคชันของคุณ ประหยัดเวลา ลดความเสี่ยง และปรับปรุงประสิทธิภาพของโค้ด ในขณะเดียวกันก็จ่ายค่าตอบแทนให้กับผู้ดูแลตามที่คุณใช้ เรียนรู้เพิ่มเติม

ภาพรวม

กำลังเชื่อมต่อกับ MongoDB

ขั้นแรก เราต้องกำหนดการเชื่อมต่อ หากแอปของคุณใช้ฐานข้อมูลเดียว คุณควรใช้ mongoose.connect หากคุณต้องการสร้างการเชื่อมต่อเพิ่มเติม ให้ใช้ mongoose.createConnection

ทั้ง connect และ createConnection ใช้ mongodb:// URI หรือพารามิเตอร์ host, database, port, options

 await mongoose . connect ( 'mongodb://127.0.0.1/my_database' ) ;

เมื่อเชื่อมต่อแล้ว เหตุการณ์ open จะเริ่มทำงานบนอินสแตนซ์ Connection หากคุณใช้ mongoose.connect Connection จะเป็น mongoose.connection มิฉะนั้น ค่าส่งคืน mongoose.createConnection จะเป็น Connection

หมายเหตุ: หากการเชื่อมต่อภายในล้มเหลว ให้ลองใช้ 127.0.0.1 แทน localhost บางครั้งปัญหาอาจเกิดขึ้นเมื่อชื่อโฮสต์ในเครื่องมีการเปลี่ยนแปลง

สำคัญ! Mongoose บัฟเฟอร์คำสั่งทั้งหมดจนกว่าจะเชื่อมต่อกับฐานข้อมูล ซึ่งหมายความว่าคุณไม่ต้องรอจนกว่าจะเชื่อมต่อกับ MongoDB เพื่อกำหนดโมเดล เรียกใช้คำสั่ง ฯลฯ

การกำหนดแบบจำลอง

โมเดลถูกกำหนดผ่านอินเทอร์เฟซ Schema

 const Schema = mongoose . Schema ;
const ObjectId = Schema . ObjectId ;

const BlogPost = new Schema ( {
  author : ObjectId ,
  title : String ,
  body : String ,
  date : Date
} ) ;

นอกเหนือจากการกำหนดโครงสร้างของเอกสารและประเภทข้อมูลที่คุณจัดเก็บแล้ว สคีมายังจัดการคำจำกัดความของ:

• เครื่องมือตรวจสอบ (async และ sync)
• ค่าเริ่มต้น
• เก็ตเตอร์
• ผู้ตั้งค่า
• ดัชนี
• มิดเดิลแวร์
• คำจำกัดความของวิธีการ
• คำนิยาม สถิตยศาสตร์
• ปลั๊กอิน
• หลอกเข้าร่วม

ตัวอย่างต่อไปนี้แสดงคุณลักษณะบางอย่างเหล่านี้:

 const Comment = new Schema ( {
  name : { type : String , default : 'hahaha' } ,
  age : { type : Number , min : 18 , index : true } ,
  bio : { type : String , match : / [a-z] / } ,
  date : { type : Date , default : Date . now } ,
  buff : Buffer
} ) ;

// a setter
Comment . path ( 'name' ) . set ( function ( v ) {
  return capitalize ( v ) ;
} ) ;

// middleware
Comment . pre ( 'save' , function ( next ) {
  notify ( this . get ( 'email' ) ) ;
  next ( ) ;
} ) ;

ดูตัวอย่างใน examples/schema/schema.js เพื่อดูตัวอย่างการตั้งค่าทั่วไปตั้งแต่ต้นจนจบ

การเข้าถึงแบบจำลอง

เมื่อเรากำหนดโมเดลผ่าน mongoose.model('ModelName', mySchema) เราก็จะสามารถเข้าถึงมันได้ผ่านฟังก์ชันเดียวกัน

 const MyModel = mongoose . model ( 'ModelName' ) ;

หรือเพียงแค่ทำทั้งหมดในครั้งเดียว

 const MyModel = mongoose . model ( 'ModelName' , mySchema ) ;

อาร์กิวเมนต์แรกคือชื่อ เอกพจน์ ของคอลเลกชันที่โมเดลของคุณใช้ Mongoose จะค้นหาชื่อรุ่นของคุณใน รูปแบบพหูพจน์ โดยอัตโนมัติ เช่น ถ้าคุณใช้

 const MyModel = mongoose . model ( 'Ticket' , mySchema ) ;

จากนั้น MyModel จะใช้การรวบรวม ตั๋ว ไม่ใช่การรวบรวม ตั๋ว สำหรับรายละเอียดเพิ่มเติม โปรดอ่านเอกสารโมเดล

เมื่อเรามีโมเดลของเราแล้ว เราก็สามารถสร้างอินสแตนซ์และบันทึกมันได้:

 const instance = new MyModel ( ) ;
instance . my . key = 'hello' ;
await instance . save ( ) ;

หรือเราสามารถค้นหาเอกสารจากคอลเลกชันเดียวกันได้

 await MyModel . find ( { } ) ;

คุณยังสามารถ findOne , findById , update ฯลฯ

 const instance = await MyModel . findOne ( { /* ... */ } ) ;
console . log ( instance . my . key ) ; // 'hello'

สำหรับรายละเอียดเพิ่มเติม โปรดดูเอกสาร

สำคัญ! หากคุณเปิดการเชื่อมต่อแยกต่างหากโดยใช้ mongoose.createConnection() แต่พยายามเข้าถึงโมเดลผ่าน mongoose.model('ModelName') มันจะไม่ทำงานตามที่คาดไว้เนื่องจากไม่ได้เชื่อมต่อกับการเชื่อมต่อ db ที่ใช้งานอยู่ ในกรณีนี้ เข้าถึงโมเดลของคุณผ่านการเชื่อมต่อที่คุณสร้างขึ้น:

 const conn = mongoose . createConnection ( 'your connection string' ) ;
const MyModel = conn . model ( 'ModelName' , schema ) ;
const m = new MyModel ( ) ;
await m . save ( ) ; // works

เทียบกับ

 const conn = mongoose . createConnection ( 'your connection string' ) ;
const MyModel = mongoose . model ( 'ModelName' , schema ) ;
const m = new MyModel ( ) ;
await m . save ( ) ; // does not work b/c the default connection object was never connected

เอกสารฝังตัว

ในตัวอย่างแรก เราได้กำหนดคีย์ใน Schema ที่มีลักษณะดังนี้:

comments: [Comment]

โดยที่ Comment คือ Schema ที่เราสร้างขึ้น ซึ่งหมายความว่าการสร้างเอกสารแบบฝังนั้นง่ายดายเพียง:

 // retrieve my model
const BlogPost = mongoose . model ( 'BlogPost' ) ;

// create a blog post
const post = new BlogPost ( ) ;

// create a comment
post . comments . push ( { title : 'My comment' } ) ;

await post . save ( ) ;

เช่นเดียวกับการลบออก:

 const post = await BlogPost . findById ( myId ) ;
post . comments [ 0 ] . deleteOne ( ) ;
await post . save ( ) ;

เอกสารแบบฝังตัวจะเพลิดเพลินกับคุณสมบัติทั้งหมดเช่นเดียวกับโมเดลของคุณ ค่าเริ่มต้น เครื่องมือตรวจสอบ มิดเดิลแวร์

มิดเดิลแวร์

ดูหน้าเอกสาร

การสกัดกั้นและการกลายพันธุ์ของอาร์กิวเมนต์ของเมธอด

คุณสามารถสกัดกั้นข้อโต้แย้งของวิธีการผ่านทางมิดเดิลแวร์

ตัวอย่างเช่น สิ่งนี้จะช่วยให้คุณสามารถถ่ายทอดการเปลี่ยนแปลงเกี่ยวกับเอกสารของคุณทุกครั้งที่มีคน set เส้นทาง sa ในเอกสารของคุณเป็นค่าใหม่:

 schema . pre ( 'set' , function ( next , path , val , typel ) {
  // `this` is the current Document
  this . emit ( 'set' , path , val ) ;

  // Pass control to the next pre
  next ( ) ;
} ) ;

นอกจากนี้ คุณสามารถเปลี่ยนอาร์กิวเมนต์ของ method ขาเข้าได้ เพื่อให้มิดเดิลแวร์ที่ตามมาเห็นค่าที่แตกต่างกันสำหรับอาร์กิวเมนต์เหล่านั้น หากต้องการทำเช่นนั้น เพียงส่งค่าใหม่ไปที่ next :

 schema . pre ( method , function firstPre ( next , methodArg1 , methodArg2 ) {
  // Mutate methodArg1
  next ( 'altered-' + methodArg1 . toString ( ) , methodArg2 ) ;
} ) ;

// pre declaration is chainable
schema . pre ( method , function secondPre ( next , methodArg1 , methodArg2 ) {
  console . log ( methodArg1 ) ;
  // => 'altered-originalValOfMethodArg1'

  console . log ( methodArg2 ) ;
  // => 'originalValOfMethodArg2'

  // Passing no arguments to `next` automatically passes along the current argument values
  // i.e., the following `next()` is equivalent to `next(methodArg1, methodArg2)`
  // and also equivalent to, with the example method arg
  // values, `next('altered-originalValOfMethodArg1', 'originalValOfMethodArg2')`
  next ( ) ;
} ) ; 

สคีมา gotcha

type เมื่อใช้ในสคีมาจะมีความหมายพิเศษภายใน Mongoose หากสคีมาของคุณต้องการการใช้ type เป็นคุณสมบัติที่ซ้อนกัน คุณต้องใช้สัญลักษณ์อ็อบเจ็กต์:

 new Schema ( {
  broken : { type : Boolean } ,
  asset : {
    name : String ,
    type : String // uh oh, it broke. asset will be interpreted as String
  }
} ) ;

new Schema ( {
  works : { type : Boolean } ,
  asset : {
    name : String ,
    type : { type : String } // works. asset is an object with a type property
  }
} ) ;

การเข้าถึงไดรเวอร์

Mongoose ถูกสร้างขึ้นบนไดรเวอร์ MongoDB Node.js อย่างเป็นทางการ พังพอนแต่ละรุ่นเก็บการอ้างอิงถึงคอลเลกชันไดรเวอร์ MongoDB ดั้งเดิม สามารถเข้าถึงวัตถุคอลเลกชันได้โดยใช้ YourModel.collection อย่างไรก็ตาม การใช้อ็อบเจ็กต์การรวบรวมจะข้ามคุณสมบัติพังพอนทั้งหมดโดยตรง รวมถึง hooks การตรวจสอบความถูกต้อง ฯลฯ ข้อยกเว้นที่น่าสังเกตประการหนึ่งที่ YourModel.collection ยังคงบัฟเฟอร์คำสั่ง ด้วยเหตุนี้ YourModel.collection.find() จะ ไม่ ส่งคืนเคอร์เซอร์

เอกสาร API

ค้นหาเอกสาร API ที่นี่ สร้างโดยใช้ dox และ acquit

โครงการที่เกี่ยวข้อง

นักวิ่ง MongoDB

• วิ่งอาร์เอส
• mongodb-หน่วยความจำเซิร์ฟเวอร์
• mongodb-โทโพโลยีผู้จัดการ

CLI ที่ไม่เป็นทางการ

• mongoosejs-cli

การเพาะข้อมูล

• คนดู
• เมล็ดห่าน
• พังพอนข้อมูลเมล็ด

ร้านค้าเซสชันด่วน

• เชื่อมต่อ mongodb-เซสชัน
• เชื่อมต่อ Mongo

ใบอนุญาต

ลิขสิทธิ์ (c) 2010 LearnBoost <[email protected]>

อนุญาตให้บุคคลใดๆ ได้รับสำเนาของซอฟต์แวร์นี้และไฟล์เอกสารที่เกี่ยวข้อง ("ซอฟต์แวร์") โดยไม่เสียค่าใช้จ่าย เพื่อจัดการกับซอฟต์แวร์โดยไม่มีข้อจำกัด รวมถึงแต่ไม่จำกัดเพียงสิทธิ์ในการใช้ คัดลอก ปรับเปลี่ยน ผสาน เผยแพร่ แจกจ่าย ให้อนุญาตช่วง และ/หรือขายสำเนาของซอฟต์แวร์ และอนุญาตให้บุคคลที่ได้รับซอฟต์แวร์นี้สามารถทำได้ ภายใต้เงื่อนไขต่อไปนี้:

ประกาศเกี่ยวกับลิขสิทธิ์ข้างต้นและประกาศการอนุญาตนี้จะรวมอยู่ในสำเนาทั้งหมดหรือส่วนสำคัญของซอฟต์แวร์

ซอฟต์แวร์นี้มีให้ 'ตามที่เป็น' โดยไม่มีการรับประกันใดๆ ทั้งโดยชัดแจ้งหรือโดยนัย ซึ่งรวมถึงแต่ไม่จำกัดเพียงการรับประกันความสามารถในการค้าขาย ความเหมาะสมสำหรับวัตถุประสงค์เฉพาะ และการไม่ละเมิด ไม่ว่าในกรณีใดผู้เขียนหรือผู้ถือลิขสิทธิ์จะต้องรับผิดต่อการเรียกร้องค่าเสียหายหรือความรับผิดอื่นใดไม่ว่าในการกระทำของสัญญาการละเมิดหรืออย่างอื่นที่เกิดขึ้นจากหรือเกี่ยวข้องกับซอฟต์แวร์หรือการใช้งานหรือข้อตกลงอื่น ๆ ใน ซอฟต์แวร์.