ChatGPT解决这个技术问题 Extra ChatGPT

How do you turn a Mongoose document into a plain object?

I have a document from a mongoose find that I want to extend before JSON encoding and sending out as a response. If I try adding properties to the doc it is ignored. The properties don't appear in Object.getOwnPropertyNames(doc) making a normal extend not possible. The strange thing is that JSON.parse(JSON.encode(doc)) works and returns an object with all of the correct properties. Is there a better way to do this?

Model.find().lean()

T
Tamlyn

Mongoose Models inherit from Documents, which have a toObject() method. I believe what you're looking for should be the result of doc.toObject().

http://mongoosejs.com/docs/api.html#document_Document-toObject


finally got it. for the ones who have toObject undefined, make sure to call on document instead of model. i.e. modelName._doc.toObject()
This is OK but lean() is preferred.
Does this work if you return array on Model.find({}) the docs return is an array. Can you docs.toObject?
@jackblank if you have an array of Models, then you should be able to map over them: var docArray = modelArray.map(function(model) { return model.toObject(); });
This sadly doesn't work for nested items afaik - the objects in my array are still mongoose special ones
J
JohnnyHK

Another way to do this is to tell Mongoose that all you need is a plain JavaScript version of the returned doc by using lean() in the query chain. That way Mongoose skips the step of creating the full model instance and you directly get a doc you can modify:

MyModel.findOne().lean().exec(function(err, doc) {
    doc.addedProperty = 'foobar';
    res.json(doc);
});

@Startec Using lean is generally more performant because you skip the overhead of first creating the full Mongoose document.
you are a champion :) correct me if I am wrong, but you should always lean() your find()s if you do not intend to modify and save the document you just received (say, if you are just trying to access the doc and send it back to your client)
@Amarsh Yes, although that's also assuming you don't need any of the instance methods or virtuals defined in the schema.
bizzare though ... this could have been an option with find() ... its often too common to read a document from a mongodb and send it back to a web browser. i wonder if find().lean() actually means find() first and then apply a lean() of each element in the result, in which case, find().lean() combination would actually be slower than find() itself.
@Amarsh No, chaining lean() on the query sets the option before the query is actually executed (by exec) so that the results are directly in their "lean" form. See this question for the positive performance impact side of calling lean.
a
alban maillere

the fast way if the property is not in the model :

document.set( key,value, { strict: false });


yes... and as suprising as it can look, I still think this could be usefull. For instance you keep all your object's primitives.
Thanks for this answer, it was what I was looking for :)
a
adir abargil

JohnnyHK suggestion:

In some cases as @JohnnyHK suggested, you would want to get the Object as a Plain Javascript. as described in this Mongoose Documentation there is another alternative to query the data directly as object:

const docs = await Model.find().lean();

Conditionally return Plain Object:

In addition if someone might want to conditionally turn to an object,it is also possible as an option argument, see find() docs at the third parameter:

const toObject = true;
const docs = await Model.find({},null,{lean:toObject});

its available on the functions: find(), findOne(), findById(), findOneAndUpdate(), and findByIdAndUpdate().

NOTE:

it is also worth mentioning that the _id attribute isn't a string object as if you would do JSON.parse(JSON.stringify(object)) but a ObjectId from mongoose types, so when comparing it to strings cast it to string before: String(object._id) === otherStringId


Put the toObject as a string, otherwise you'll get an error. Thank you for the solution.
J
Jalasem

A better way of tackling an issue like this is using doc.toObject() like this

doc.toObject({ getters: true })

other options include:

getters: apply all getters (path and virtual getters)

virtuals: apply virtual getters (can override getters option)

minimize: remove empty objects (defaults to true)

transform: a transform function to apply to the resulting document before returning

depopulate: depopulate any populated paths, replacing them with their original refs (defaults to false)

versionKey: whether to include the version key (defaults to true)

so for example you can say

Model.findOne().exec((err, doc) => {
   if (!err) {
      doc.toObject({ getters: true })
      console.log('doc _id:', doc._id)
   }
})

and now it will work.

For reference, see: http://mongoosejs.com/docs/api.html#document_Document-toObject


d
dd619

To get plain object from Mongoose document, I used _doc property as follows

mongooseDoc._doc  //returns plain json object

I tried with toObject but it gave me functions,arguments and all other things which i don't need.


Accessing properties or methods with _ in the beginning is not the ideal solution. Using lean might solve your case.
@ArthurBrito yes. Its not a ideal solution but its still a SOLUTION! I have used _doc property many times without facing any issue. And using lean method gives you plain object on which you can't perform mongoose model operations.
A
Amir BenAmara

The lean option tells Mongoose to skip hydrating the result documents. This makes queries faster and less memory intensive, but the result documents are plain old JavaScript objects (POJOs), not Mongoose documents.

const leanDoc = await MyModel.findOne().lean();

not necessary to use JSON.parse() method


k
kaushik_pm

You can also stringify the object and then again parse to make the normal object. For example like:-

const obj = JSON.parse(JSON.stringify(mongoObj))

this also has advantage of getting the _id as a string.
JSON.parse is a very slow command and quite heavy on performance.
Really how did you gauge it's speed @BertC
@chuklore, various articles like this one: itnext.io/…
C
Cizia

I have been using the toObject method on my document without success. I needed to add the flattenMap property to true to finally have a POJO.

const data = document.data.toObject({ flattenMaps: true });