是什么？

• mongoose的核心是mongoose（）构造函数
• mongoose是一个ODM（对象数据模型）。（Object Data Model）
  使用JS对象的语法来映射Mongodb数据库中的表和document
  collection:数据库中的表
  Document：表中的一条记录
• mongoose是一个对象
• mongoose是mongodb的对象建模工具
• mongoose用于和mongodb通信的函数库（增删改查）
• mongoose运行在node平台上
• mongoose是一个构造函数
  在文件中引入mongoose，会自动创建一个实例对象

mongoose.connect()

用于连接mongodb数据库
它是一个异步函数
语法：

mongoose.connect(uri)
mongoose.connect(数据库连接字符串)

返回值连接成功返回一个promise

promise.then()

then()最多接受两个参数：
已完成的回调函数
已拒绝的回调函数
语法：

promise.then(resolved,rejected)
promise.then((data)=>{
异步操作成果
},(error)=>{
输出错误原因
})

一个·参数

promise.then((data)=>{
异步操作成果
}.then()
.then()
.catch()//捕获错误信息
//链式调用

返回值：返回一个等效的promise对象

mongoose.model()

定义数据模型
用于·创建与mongodb数据库交互工具
交互工具在这里就是一个构造函数
构造函数可以实例化一个对象
通过实例对象的方法与数据库进行通信。
语法：

const Blog = mongoose.model("模型名称"，模型原型)
const Blog = mongoose.model("模型名称"，blogSchema)

返回值：返回大写的Model构造函数

什么叫定义数据结构

定义数据结构就算定义：字段，字段类型，字段其他属性

{
title:{字段
type：String//字段类型
required：true//字段其他属性
}
}

promise.catch()

用于为promise绑定回调请求失败时的回调函数
用于捕获错误信息
语法：

promise.catch(err=>{})

返回值：返回一个等效的promise对象

Schema（）

是一个构造函数
定义数据结构模型
Schema（）构造函数用于创建实例对象
每一个Schema实例对象映射一个Mongodb数据库表
定义表中的document结构
语法：

new Schema（obj,options）
new Schema（定义数据库表结构，{选项对象：描述前面的表}）

options:选项对象
返回值：返回一个Schma对象，表示数据结构
实例：

const blogSchema = new Schema({
    title: {
        type: String, 
        required: true
    }, 
    author: {
        type: String, 
        required: true
    }, 
    snippet:  {
        type: String, 
        required: true
    }, 
    body:  {
        type: String, 
        required: true
    }
 },{})

打印mongoose

• Mongoose.connections：构建
• Mongoose.Schema：构造函数
• Mongoose.model:函数

<ref *1> Mongoose {
connections: [
NativeConnection {
base: [Circular *1],
collections: [Object],
models: [Object],
config: {},

  replica: false,
  options: null,
  otherDbs: [],
  relatedDbs: {},
  states: [Object: null prototype],  
  _readyState: 0,
  _closeCalled: false,
  _hasOpened: false,
  plugins: [],
  id: 0,
  _queue: [Array],
  _listening: false
}

],
nextConnectionId: 1,
models: { Blog: Model { Blog } },
events: EventEmitter {
_events: [Object: null prototype] {},
_eventsCount: 0,
_maxListeners: undefined,
[Symbol(kCapture)]: false
},
__driver: {
Collection: [Function: NativeCollection],
Connection: [Function: NativeConnection] { STATES: [Object: null prototype] }
},
options: {
pluralization: true,
autoIndex: true,
autoCreate: true,
[Symbol(mongoose:default)]: true
},
_pluralize: [Function: pluralize],
Schema: [Function: Schema] {
reserved: [Object: null prototype] {
validate: 1,
toObject: 1,
save: 1,
remove: 1,
populated: 1,
isNew: 1,
isModified: 1,
init: 1,
get: 1,
errors: 1,
collection: 1,
removeListener: 1,
listeners: 1,
emit: 1,
prototype: },
Types: {
String: [Function],
Number: [Function],
Boolean: [Function],
DocumentArray: [Function],
Subdocument: [Function],
Array: [Function],
Buffer: [Function],
Date: [Function],
ObjectId: [Function],
Mixed: [Function],
Decimal: [Function],
Decimal128: [Function],
Map: [Function],
UUID: [Function],
Oid: [Function],
Object: [Function],
Bool: [Function],
ObjectID: [Function]
},
ObjectId: [Function: ObjectId] {
schemaName: 'ObjectId',
defaultOptions: {},
get: [Function (anonymous)],
set: [Function: set],
_checkRequired: [Function (anonymous)],
_cast: [Function: castObjectId],
cast: [Function: cast],
_defaultCaster: [Function (anonymous)],
checkRequired: [Function (anonymous)]
}
},
model: [Function (anonymous)],
plugins: [
[ [Function: removeSubdocs], [Object] ],
[ [Function: saveSubdocs], [Object] ],
[ [Function], [Object] ],
[ [Function: trackTransaction], [Object] ],
[ [Function: validateBeforeSave], [Object] ]
],
default: [Circular *1],
mongoose: [Circular *1],
cast: [Function: cast],
STATES: [Object: null prototype] {
'0': 'disconnected',
'1': 'connected',
'2': 'connecting',
'3': 'disconnecting',
'99': 'uninitialized',
disconnected: 0,
connected: 1,
connecting: 2,
disconnecting: 3,
uninitialized: 99
},
setDriver: [Function: setDriver],
set: [Function (anonymous)],
get: [Function (anonymous)],
createConnection: [Function (anonymous)],
connect: [AsyncFunction: connect],
disconnect: [AsyncFunction: disconnect],
startSession: [Function (anonymous)],
pluralize: [Function (anonymous)],
deleteModel: [Function (anonymous)],
modelNames: [Function (anonymous)],
plugin: [Function (anonymous)],
version: '7.0.3',
Mongoose: [Function: Mongoose],
SchemaType: [Function: SchemaType] {
cast: [Function: cast],
set: [Function: set],
get: [Function (anonymous)],
_isRef: [Function (anonymous)],
checkRequired: [Function (anonymous)],
CastError: [class CastError extends MongooseError],
ValidatorError: [class ValidatorError extends MongooseError]
},
SchemaTypes: {
String: [Function: SchemaString] {
schemaName: 'String',
defaultOptions: {},
_cast: [Function: castString],
cast: [Function: cast],
_defaultCaster: [Function (anonymous)],
get: [Function (anonymous)],
set: [Function: set],
_checkRequired: [Function (anonymous)],
checkRequired: [Function (anonymous)]
},
Number: [Function: SchemaNumber] {
get: [Function (anonymous)],
set: [Function: set],
_cast: [Function: castNumber],
cast: [Function: cast],
_defaultCaster: [Function (anonymous)],
schemaName: 'Number',
defaultOptions: {},
_checkRequired: [Function (anonymous)],
checkRequired: [Function (anonymous)]
},
Boolean: [Function: SchemaBoolean] {
schemaName: 'Boolean',
defaultOptions: {},
_cast: [Function],
set: [Function: set],
cast: [Function: cast],
_defaultCaster: [Function (anonymous)],
_checkRequired: [Function (anonymous)],
checkRequired: [Function (anonymous)],
'conditionalHandlers': [Object]
},
ObjectID: [Function: ObjectId] {
schemaName: 'ObjectId',
defaultOptions: {},
get: [Function (anonymous)],
set: [Function: set],
_checkRequired: [Function (anonymous)],
_cast: [Function: castObjectId],
cast: [Function: cast],
_defaultCaster: [Function (anonymous)],
checkRequired: [Function (anonymous)]
}
},
VirtualType: [Function: VirtualType],
Types: {
Array: [Function: MongooseArray],
Buffer: [Function: MongooseBuffer] {
pathSymbol: Symbol(mongoose#Buffer#_path),
mixin: [Object],
Binary: [Function]
},
Embedded: [Function: ArraySubdocument] {
_events: undefined,
_eventsCount: 0,
_maxListeners: undefined,
setMaxListeners: [Function: setMaxListeners],
getMaxListeners: [Function: getMaxListeners],
emit: [Function: emit],
addListener: [Function: addListener],
on: [Function: addListener],
prependListener: [Function: prependListener],
once: [Function: once],
prependOnceListener: [Function: prependOnceListener],
removeListener: [Function: removeListener],
off: [Function: removeListener],
removeAllListeners: [Function: removeAllListeners],
listeners: [Function: listeners],
rawListeners: [Function: rawListeners],
listenerCount: [Function: listenerCount],
eventNames: [Function: eventNames]
},
Document: [Function: ArraySubdocument] {
_events: undefined,
_eventsCount: 0,
_maxListeners: undefined,
setMaxListeners: [Function: setMaxListeners],
getMaxListeners: [Function: getMaxListeners],
emit: [Function: emit],
addListener: [Function: addListener],
on: [Function: addListener],
prependListener: [Function: prependListener],
once: [Function: once],
prependOnceListener: [Function: prependOnceListener],
removeListener: [Function: removeListener],
off: [Function: removeListener],
removeAllListeners: [Function: removeAllListeners],
listeners: [Function: listeners],
rawListeners: [Function: rawListeners],
listenerCount: [Function: listenerCount],
eventNames: [Function: eventNames]
},
DocumentArray: [Function: MongooseDocumentArray],
Decimal128: [class Decimal128 extends BSONValue],
ObjectId: [class ObjectId extends BSONValue] { index: 3005263 },
Map: [class MongooseMap extends Map],
Subdocument: [Function: Subdocument]
},
Query: [Function: Query] {
base: {
toConstructor: [Function: toConstructor],
setOptions: [Function (anonymous)],
collection: [Function: collection],
collation: [Function (anonymous)],
'geoWithin': true
},
Model: Model { undefined },
Document: [Function: Document] {
_events: undefined,
_eventsCount: 0,
_maxListeners: undefined,
setMaxListeners: [Function: setMaxListeners],
getMaxListeners: [Function: getMaxListeners],
emit: [Function: emit],
addListener: [Function: addListener],
on: [Function: addListener],
prependListener: [Function: prependListener],
once: [Function: once],
prependOnceListener: [Function: prependOnceListener],
removeListener: [Function: removeListener],
off: [Function: removeListener],
removeAllListeners: [Function: removeAllListeners],
listeners: [Function: listeners],
rawListeners: [Function: rawListeners],
listenerCount: [Function: listenerCount],
eventNames: [Function: eventNames],
ValidationError: [class ValidationError extends MongooseError]
},
ObjectId: [Function: ObjectId] {
schemaName: 'ObjectId',
defaultOptions: {},
get: [Function (anonymous)],
set: [Function: set],
_checkRequired: [Function (anonymous)],
_cast: [Function: castObjectId],
cast: [Function: cast],
_defaultCaster: [Function (anonymous)],
checkRequired: [Function (anonymous)]
},
isValidObjectId: [Function (anonymous)],
isObjectIdOrHexString: [Function (anonymous)],
syncIndexes: [Function (anonymous)],
Decimal128: [Function: Decimal128] {
schemaName: 'Decimal128',
defaultOptions: {},
_cast: [Function: castDecimal128],
set: [Function: set],
cast: [Function: cast],
_defaultCaster: [Function (anonymous)],
_checkRequired: [Function (anonymous)],
checkRequired: [Function (anonymous)]
},
Mixed: [Function: Mixed] {
schemaName: 'Mixed',
defaultOptions: {},
get: [Function (anonymous)],
set: [Function: set]
},
Date: [Function: SchemaDate] {
schemaName: 'Date',
defaultOptions: {},
_cast: [Function: castDate],
set: [Function: set],
cast: [Function: cast],
_defaultCaster: [Function (anonymous)],
_checkRequired: [Function (anonymous)],
checkRequired: [Function (anonymous)]
},
Number: [Function: SchemaNumber] {
get: [Function (anonymous)],
set: [Function: set],
_cast: [Function: castNumber],
cast: [Function: cast],
_defaultCaster: [Function (anonymous)],
schemaName: 'Number',
defaultOptions: {},
_checkRequired: [Function (anonymous)],
checkRequired: [Function (anonymous)]
},
Error: [class MongooseError extends Error] {
messages: {
DocumentNotFoundError: null,
general: [Object],
Number: [Object],
Date: [Object],
String: [Object]
},
Messages: {
DocumentNotFoundError: null,
general: [Object],
Number: [Object],
Date: [Object],
String: [Object]
},
DocumentNotFoundError: [class DocumentNotFoundError extends MongooseError],
CastError: [class CastError extends MongooseError],
ValidationError: [class ValidationError extends MongooseError],
ValidatorError: [class ValidatorError extends MongooseError],
VersionError: [class VersionError extends MongooseError],
ParallelSaveError: [class ParallelSaveError extends MongooseError],
OverwriteModelError: [class OverwriteModelError extends MongooseError],
MissingSchemaError: [class MissingSchemaError extends MongooseError],
MongooseServerSelectionError: [class MongooseServerSelectionError extends MongooseError],
DivergentArrayError: [class DivergentArrayError extends MongooseError],
StrictModeError: [class StrictModeError extends MongooseError],
StrictPopulateError: [class StrictPopulateError extends MongooseError]
},
now: [Function: now],
CastError: [class CastError extends MongooseError],
SchemaTypeOptions: [class SchemaTypeOptions],
mongo: {
BSON: [Getter],
Binary: [Getter],
BSONRegExp: [Getter],
BSONSymbol: [Getter],
BSONType: [Getter],
Code: [Getter],
DBRef: [Getter],
Decimal128: [Getter],
Double: [Getter],
Int32: [Getter],
Long: [Getter],
MaxKey: [Getter],
MinKey: [Getter],
ObjectId: [Getter],
Timestamp: [Getter],
MongoBulkWriteError: [Getter],
ChangeStreamCursor: [Getter],
MongoAPIError: [Getter],
MongoAWSError: [Getter],
MongoBatchReExecutionError: [Getter],
MongoChangeStreamError: [Getter],
MongoCompatibilityError: [Getter],
MongoCursorExhaustedError: [Getter],
MongoCursorInUseError: [Getter],
MongoDecompressionError: [Getter],
MongoDriverError: [Getter],
MongoError: [Getter],
MongoExpiredSessionError: [Getter],
MongoGridFSChunkError: [Getter],
MongoGridFSStreamError: [Getter],
MongoInvalidArgumentError: [Getter],
MongoKerberosError: [Getter],
MongoMissingCredentialsError: [Getter],
MongoMissingDependencyError: [Getter],
MongoNetworkError: [Getter],
MongoNetworkTimeoutError: [Getter],
MongoNotConnectedError: [Getter],
MongoParseError: [Getter],
MongoRuntimeError: [Getter],
MongoServerClosedError: [Getter],
MongoServerError: [Getter],
MongoServerSelectionError: [Getter],
MongoSystemError: [Getter],
MongoTailableCursorError: [Getter],
MongoTopologyClosedError: [Getter],
MongoTransactionError: [Getter],
MongoUnexpectedServerResponseError: [Getter],
MongoWriteConcernError: [Getter],
AbstractCursor: [Getter],
Admin: [Getter],
AggregationCursor: [Getter],
CancellationToken: [Getter],
ChangeStream: [Getter],
ClientSession: [Getter],
Collection: [Getter],
Db: [Getter],
FindCursor: [Getter],
GridFSBucket: [Getter],
GridFSBucketReadStream: [Getter],
GridFSBucketWriteStream: [Getter],
ListCollectionsCursor: [Getter],
ListIndexesCursor: [Getter],
MongoClient: [Getter],
OrderedBulkOperation: [Getter],
UnorderedBulkOperation: [Getter],
BatchType: [Getter],
GSSAPICanonicalizationValue: [Getter],
AuthMechanism: [Getter],
Compressor: [Getter],
CURSOR_FLAGS: [Getter],
AutoEncryptionLoggerLevel: [Getter],
MongoErrorLabel: [Getter],
ExplainVerbosity: [Getter],
ServerApiVersion: [Getter],
ReturnDocument: [Getter],
ProfilingLevel: [Getter],
ReadConcernLevel: [Getter],
ReadPreferenceMode: [Getter],
ServerType: [Getter],
TopologyType: [Getter],
ReadConcern: [Getter],
ReadPreference: [Getter],
WriteConcern: [Getter],
CommandFailedEvent: [Getter],
CommandStartedEvent: [Getter],
CommandSucceededEvent: [Getter],
ConnectionCheckedInEvent: [Getter],
ConnectionCheckedOutEvent: [Getter],
ConnectionCheckOutFailedEvent: [Getter],
ConnectionCheckOutStartedEvent: [Getter],
ConnectionClosedEvent: [Getter],
ConnectionCreatedEvent: [Getter],
ConnectionPoolClearedEvent: [Getter],
ConnectionPoolClosedEvent: [Getter],
ConnectionPoolCreatedEvent: [Getter],
ConnectionPoolMonitoringEvent: [Getter],
ConnectionPoolReadyEvent: [Getter],
ConnectionReadyEvent: [Getter],
ServerClosedEvent: [Getter],
ServerDescriptionChangedEvent: [Getter],
ServerHeartbeatFailedEvent: [Getter],
ServerHeartbeatStartedEvent: [Getter],
ServerHeartbeatSucceededEvent: [Getter],
ServerOpeningEvent: [Getter],
TopologyClosedEvent: [Getter],
TopologyDescriptionChangedEvent: [Getter],
TopologyOpeningEvent: [Getter],
SrvPollingEvent: [Getter]
},
mquery: [Function: Query] {
permissions: {
distinct: [Function],
findOneAndRemove: [Function],
findOneAndUpdate: [Function],
count: [Function]
},
_isPermitted: [Function (anonymous)],
canMerge: [Function (anonymous)],
setGlobalTraceFunction: [Function (anonymous)],
utils: {
clone: [Function: clone],
cloneObject: [Function: cloneObject],
cloneArray: [Function: cloneArray],
merge: [Function: merge],
mergeClone: [Function: mergeClone],
readPref: [Function: readPref],
readConcern: [Function: readConcern],
toString: [Function (anonymous)],
isObject: [Function (anonymous)],
keys: [Function: keys],
create: [Function: create],
inherits: [Function (anonymous)],
isArgumentsObject: [Function (anonymous)]
},
env: { isNode: [Array], isMongo: false, isBrowser: false, type: 'node' },
Collection: [class NodeCollection extends Collection],
BaseCollection: [Function: Collection] { methods: [Array] }
},
sanitizeFilter: [Function: sanitizeFilter],
trusted: [Function: trusted],
skipMiddlewareFunction: [Function: skipWrappedFunction],
overwriteMiddlewareResult: [Function: overwriteResult]
}