Mongoose: जब कोई संपत्ति किसी स्कीमा का संदर्भ देती है तो खाली सरणी सहेजी जाती है

को निर्मित 6 फ़र॰ 2013 · 39टिप्पणियाँ · स्रोत: Automattic/mongoose

var FooSchema = new Schema({});
var Foo = mongoose.model("Foo", FooSchema);
var BarSchema = new Schema({
    foos: [Foo.schema]
});
var Bar = mongoose.model("Bar", BarSchema);

var b = new Bar();
b.save();

यह केवल संपत्ति को अपरिभाषित छोड़ने के बजाय b.foos की एक खाली सरणी बनाएगा।

enhancement

स्रोत

lookfirst

👍1

सबसे उपयोगी टिप्पणी

@antonioaltamura मैं इस मुद्दे के बारे में भूल गया, नीचे नेवला 4.6 में काम करता है:

const CollectionSchema = new Schema({
 field1: { type: [String], default: void 0 }, // <-- override the array default to be undefined
});

const Collection = mongoose.model('test', CollectionSchema);

Collection.create({}).
  then(doc => { console.log(doc); return doc; }).
  then(() => { process.exit(0); });

vkarpov15 7 अक्तू॰ 2016

👍27 ❤12

सभी 39 टिप्पणियाँ

यह डिजाइन द्वारा है। सभी डिफ़ॉल्ट मान सहेजे जाते हैं, इसलिए दस्तावेज़ का नेवला एप्लिकेशन दृश्य गैर-नेवला एप्लिकेशन दृश्य के समान होता है।

aheckmann 7 फ़र॰ 2013

ठीक है, मैं डिफ़ॉल्ट शून्य कैसे बनाऊं? ;-) यहां उपयोग की बात यह है कि मोंगो में उन सभी बार का अनुरोध करना महंगा है जिनके पास खाली फू हैं। मुझे उस राज्य को ट्रैक करने के लिए एक और संपत्ति जोड़नी है, जो मेरे कोड को और अधिक जटिल बनाती है।

lookfirst 7 फ़र॰ 2013

👍1

अच्छा ऐसा है। यह आपको नए दस्तावेज़ों में खाली फ़ूज़ को सहेजना छोड़ देगा:

BarSchema.pre('save', function (next) {
  if (this.isNew && 0 === this.foos.length) {
    this.foos = undefined;                                                                                                                                   
  }
  next();
})

aheckmann 7 फ़र॰ 2013

👎6 🎉2

मिठाई। यह मेरे लिए काफी अच्छा कामकाज है।

lookfirst 7 फ़र॰ 2013

क्या यह वर्कअराउंड अभी भी काम करने वाला है? (नेवला 3.8.3 यहाँ)

mathieumg 21 दिस॰ 2013

Mathieumg: यह मेरे लिए काम नहीं करता (3.8.15)

Nepoxx 25 अग॰ 2014

हां, मुझे लगता है कि यह मुद्दा कुछ ध्यान देने योग्य है। (यह बहुत मामूली है, लेकिन
मुझे अन्य चीजों के लिए प्री का उपयोग करने में दिलचस्पी है :))

सोम, अगस्त २५, २०१४ अपराह्न ४:४९ बजे, मैथ्यू एम-गोसलिन <
सूचनाएं@github.com> ने लिखा:

शायद मुझे इस पर ध्यान देने के लिए एक नया मुद्दा खोलना चाहिए?
-
इस ईमेल का सीधे उत्तर दें या इसे GitHub पर देखें
https://github.com/LearnBoost/mongoose/issues/1335#issuecomment -53328195
.

Nepoxx 26 अग॰ 2014

+1
पूर्व कार्य 3.8.15 . के लिए काम नहीं कर रहा है
मुझे लगता है कि एकमात्र विकल्प क्वेरी को सरल बनाने के लिए शून्य या गलत है, लेकिन यह कुछ बाइट्स भी जोड़ता है और बड़े डेटाबेस पर महत्वपूर्ण प्रभाव डालता है।

        this.foos = null;

gaurang171 16 सित॰ 2014

@ gaurang171 @Nepoxx क्या आप मुझे कुछ कोड प्रदान कर सकते हैं जो इसे पुन: पेश करता है? हमारे परीक्षण मामलों में समाधान ठीक काम करता है (देखें परीक्षण मामला )

vkarpov15 13 अक्तू॰ 2014

4.0.1 का उपयोग करके यह अभी भी मेरे लिए एक मुद्दा है।

viking 8 अप्रैल 2015

var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/test');

var barSchema = new mongoose.Schema({
  baz: String
});

var fooSchema = new mongoose.Schema({
  bars: [barSchema]
});

var Foo = mongoose.model('Foo', fooSchema);

var foo = new Foo();
console.log(foo); // { _id: 55256e20e3c38434687034fb, bars: [] }

foo.save(function(err, foo2) {
  console.log(foo2); // { __v: 0, _id: 55256e20e3c38434687034fb, bars: [] }

  foo2.bars = undefined;
  foo2.save(function(err, foo3) {
    console.log(foo3); // { __v: 0, _id: 55256e20e3c38434687034fb, bars: undefined }

    Foo.findOne({ _id: foo3._id }, function(err, foo4) {
      console.log(foo4); // { _id: 55256e20e3c38434687034fb, __v: 0, bars: [] }

      mongoose.disconnect();
    });
  });
});

viking 8 अप्रैल 2015

@viking यह कभी 'तय' नहीं था। एक उपाय प्रदान किया गया था । आपको यह देखने के लिए परीक्षण करना चाहिए कि क्या वह समाधान अभी भी काम करता है क्योंकि उसके बारे में परस्पर विरोधी जानकारी है। =)

lookfirst 9 अप्रैल 2015

👍1

मेरे पास पहले से ही एक समाधान है। मुझे यह जानने में दिलचस्पी है कि यह व्यवहार बदलेगा या नहीं।

viking 9 अप्रैल 2015

क्षमा करें, आपने यह नहीं कहा कि आप जानना चाहते हैं कि व्यवहार बदलेगा या नहीं।

मुझे वास्तव में यकीन नहीं है कि इस मुद्दे को @ vkarpov15 द्वारा फिर से क्यों खोला गया, जो इस सवाल का भीख माँगता है कि यह व्यवहार बदलेगा या नहीं। मुझे लगता है कि मुद्दा पश्चगामी संगतता है। यह शायद 4.x बाहर जाने से पहले तय हो जाना चाहिए था।

lookfirst 9 अप्रैल 2015

हाँ यह व्यवहार निकट भविष्य में नहीं बदलेगा। मैंने इस मुद्दे को फिर से खोला, इसलिए जब मुझे मौका मिला तो मैं इसकी जांच करना जानता था, क्योंकि मैं यह समझना सुनिश्चित करता हूं कि नेवले जीथब में आने वाली हर टिप्पणी के साथ क्या हो रहा है और यह वह था जिसका मेरे पास अच्छा जवाब नहीं था मेरे सिर के ऊपर से दूर करने के लिए। अधिक बारीकी से देखने पर, हम निकट भविष्य में सेवर के कारण इसे वास्तव में नहीं बदल सकते हैं, लेकिन यह जांचने के लिए कुछ है कि क्या यह बहुत सारे उपयोगकर्ताओं के लिए एक दर्द बिंदु है।

vkarpov15 10 अप्रैल 2015

मैंने इस वर्कअराउंड को एक ट्विस्ट के साथ इस्तेमाल किया है क्योंकि कभी-कभी आप एक खाली ऐरे लिखना चाहते हैं और कभी-कभी नहीं।

तो मेरा प्रीसेव इस तरह दिखता है:

        var schema = mongoose.Schema({
                   ...
           "children": [ String ]
                   ...
            });
        // turn off the saving of empty children if there are no children in the schema.
        schema.pre('save', function (next) {
            if (this.isNew) {
                if (this.children.length == 0) {
                    this.children = undefined;       
                }
                else if (this.children.length == 1 && this.children[0] == null) {
                    this.children = [];
                }                                                                                                                    
            }
            next();
        });
        var model = mongoose.model('MyDocument', schema);

और फिर खाली बच्चों को लिखने के लिए मैं इसका इस्तेमाल करता हूं:

idea.children = [null];

जबकि यह छीन लिया गया है:

idea.children = [];

यह आपके काम नहीं आ सकता है लेकिन आपको किसी अन्य प्रकार की योजना के साथ आने में सक्षम होना चाहिए।

phamtec 24 अप्रैल 2015

यह एक बहुत बड़ी समस्या है जब आपके पास नेस्टेड ऑब्जेक्ट्स के अंदर सरणियाँ होती हैं।

var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/test');

var quxSchema = new mongoose.Schema({ qux: String });
var fooSchema = new mongoose.Schema({ foo: { bar: { baz: [ quxSchema ] } } });
var Foo = mongoose.model('Foo', fooSchema);

var foo = new Foo({foo: undefined})
foo.save(function(err, foo) {
  console.log(JSON.stringify(foo)); // {"__v":0,"_id":"557ae56480f047fd4ff4ab26","foo":{"bar":{"baz":[]}}}
  Foo.find({ _id: foo._id }, function(err, foos) {
    console.log(JSON.stringify(foos[0])); // {"_id":"557ae56480f047fd4ff4ab26","__v":0,"foo":{"bar":{"baz":[]}}}
  });
});

यहां मुझे उम्मीद है कि foo गायब है, और इसके बजाय मेरे पास यह नेस्टेड ऑब्जेक्ट एक खाली सरणी के साथ है।

viking 12 जून 2015

❤3

लेकिन क्या यहां प्री सेव आपकी मदद नहीं कर सकता? {foo: undefined} होने के बजाय आप एक अद्वितीय प्रकार के foo का उपयोग अशक्त foo को इंगित करने के लिए कर सकते हैं, और फिर foo को प्रीसेव में निकाल सकते हैं।

हालांकि बदसूरत।

phamtec 13 जून 2015

मैं बस उसी मुद्दे में भाग गया जैसे @viking ने किया था। क्या आपको कोई प्रयोग करने योग्य समाधान मिला?

मैंने इसे 'प्री' सेव तरीके से करने की कोशिश की .. लेकिन यह अभी भी कभी-कभी होता है, मुझे यकीन नहीं है कि इसे पूरा करने के लिए मुझे कितने अलग-अलग उपयोग के मामलों को कवर करना होगा। इसमें से मेरी सबसे बड़ी समस्या यह है कि JSON को वास्तव में एक वस्तु वितरित करनी चाहिए, न कि एक सरणी। यह मेरे जेसन पार्सर के लिए एक घातक अपवाद है जो इन चीजों को जावा ऑब्जेक्ट्स में मैप करने का प्रयास करता है।

उदाहरण:

var subA = mongoose.Schema({
     name: String,
     a: String
});

var subB = mongoose.Schema({
     name: String,
     b: String
});

var A = mongoose.Schema({
name: String,
filter: {
        lastupdate  : { type: Date, default: Date.now },
        subA: [{type: Schema.Types.ObjectId, ref: 'subA', unique: true}],
        subB: [{type: Schema.Types.ObjectId, ref: 'subB', unique: true}]
    }
});

var ModelA = mongoose.model('A', A);

var obj = new modelA();
obj.save();

... इसका परिणाम है:

{
 filter: []
}

लेकिन यह या तो वहां नहीं होना चाहिए, या कम से कम एक वस्तु होना चाहिए और खाली सरणी नहीं होनी चाहिए:

{
 filter: {} 
}

किसी को कोई विचार है कि इसे कैसे हल किया जाए?

सादर

simllll 27 जुल॰ 2015

मुझे लगता है कि आप यह काम कर सकते हैं, जाहिर तौर पर मेरे द्वारा पोस्ट किए गए प्रीसेव के साथ नहीं, क्योंकि इसमें बच्चे शामिल हैं जो एक वस्तु नहीं है। मैंने यह कोशिश नहीं की है, लेकिन क्या वास्तव में "बतख टाइपिंग" खाली वस्तु का उपयोग वास्तविक खाली को इंगित करने के लिए संभव नहीं होगा?

तो आपका बचाव हो सकता है:

if (this.isNew) {
    if (typeof(this.filter.empty) != "undefined") {
        this.filter = {};
    }
}

फिर एक वास्तविक खाली फ़िल्टर बनाने के लिए आप इसका उपयोग कर सकते हैं:

var obj = new modelA();
obj.filter = { empty: true };
obj.save();

ध्यान दें कि यह वास्तव में कोई फर्क नहीं पड़ता कि स्कीमा में "खाली" नहीं है, यह इसे कभी भी नेवला नहीं बनाता है।

phamtec 28 जुल॰ 2015

किसी तरह मैंने इस मुद्दे को दूर करने का एक तरीका प्रबंधित किया .. मैंने वास्तव में कुछ ऐसा ही किया। हालांकि अभी आपका जवाब देखा और धन्यवाद कहना चाहता था :)

सादर
साइमन

simllll 7 अक्तू॰ 2015

वैकल्पिक Array फ़ील्ड के साथ नेस्टेड स्कीमा होने पर मुझे इस समाधान के साथ बहुत सी समस्याएं आ रही थीं। मैंने इसे एक नया प्रकार बनाकर हल किया:

optional_array = 
  type: Mixed
  validate: 
    validator: (v) ->
      return v instanceof Array
    message: '{VALUE} needs to be an array.'

और फिर मेरे सभी क्षेत्रों को optional_array बजाय Array ।

maxko87 15 अक्तू॰ 2015

@simllll मैं लापता वस्तुओं के लिए null प्लेसहोल्डर का उपयोग करता हूं और फिर ऑब्जेक्ट का उपयोग करने से पहले null हटा देता हूं।

viking 22 अक्तू॰ 2015

क्षमा करें, लेकिन यह एक भयानक डिजाइन है। आपको मेरी ओर से निर्णय नहीं लेना चाहिए, मैं चाहता हूं कि यह एक खाली सरणी हो या बिल्कुल भी सेट न हो। कम से कम इस सुविधा को अक्षम करने का विकल्प प्रदान करें।

ifeltsweet 10 फ़र॰ 2016

👍21 ❤8

@ifeltsweet . से सहमत हैं

dpaczewski 3 अप्रैल 2016

महीनों के बाद, बिना प्री-हुक के कोई उचित समाधान है? मेरे पास दर्जनों सरणी फ़ील्ड हैं, मुझे एक पूर्व हुक में एक-एक करके संभालना चाहिए ...

antonioaltamura 4 अक्तू॰ 2016

@antonioaltamura मैं इस मुद्दे के बारे में भूल गया, नीचे नेवला 4.6 में काम करता है:

const CollectionSchema = new Schema({
 field1: { type: [String], default: void 0 }, // <-- override the array default to be undefined
});

const Collection = mongoose.model('test', CollectionSchema);

Collection.create({}).
  then(doc => { console.log(doc); return doc; }).
  then(() => { process.exit(0); });

vkarpov15 7 अक्तू॰ 2016

👍27 ❤12

@ vkarpov15 आपका फिक्स मेरे लिए नेवला 4.7.0 पर काम नहीं करता है। अभी भी आपके लिए ठीक काम कर रहा है? इसमें नई वस्तु निर्माण पर मूल्य शामिल नहीं है, लेकिन जब मैं Model.save करता हूं तो यह इसे फिर से जोड़ने का प्रयास करता है।

cpup22 1 दिस॰ 2016

😕1

@ cup22 क्या आप एक कोड नमूना प्रदान कर सकते हैं? संदर्भित स्क्रिप्ट मेरे लिए 4.7.1 पर ठीक काम करती है।

vkarpov15 4 दिस॰ 2016

मुझे लगता है कि https://github.com/Automattic/mongoose/issues/2363#issuecomment -171988413 से वर्कअराउंड ज्यादा साफ है। यह null डिफ़ॉल्ट होने की अनुमति देता है, तब भी जब default: null विफल हो जाता है:

const CollectionSchema = new Schema({
  field1: { type: [String] },
});
CollectionSchema.methods.postconstructed = function () {
  this.field1 = null;
};
CollectionSchema.queue('postconstructed');

const Collection = mongoose.model('test', CollectionSchema);

Collection.create({}).then(doc => { console.log(doc); process.exit(0) });

binki 11 अग॰ 2017

कोई बात नहीं, यह एक मूल्य में गुजरते समय काम नहीं करता है (उदाहरण के लिए, new Collection({ field1: [] }) field1 === null हो जाता है। यदि केवल एक निर्माण हुक था जो डेटा में पारित होने से पहले और डिफ़ॉल्ट के बाद हुआ था खाली सरणी बनाई गई है। या इस बग को सरणी के लिए default: null अनुमति देने के लिए तय किया गया था।

binki 11 अग॰ 2017

ओह, ऐसा लगता है कि यह काम करता है:

const CollectionSchema = new Schema({
  field1: { type: [String], default: () => null },
});

सरणी प्रकार की चीज मूल्यों की तुलना में अधिक ईमानदारी से कार्यों का सम्मान करती है। इसमें पास-इन null , [] , या Collection.create() या new Collection() माध्यम से गैर-खाली सरणी मान को ओवरराइट करने में कोई समस्या नहीं है।

binki 11 अग॰ 2017

@ vkarpov15 नमस्ते वहाँ, इसलिए भले ही मैं
आपके पास कोई उपाय है

vikramkalta 21 अग॰ 2017

@vikramkalta कृपया कोड नमूने प्रदान करें, कोड रूपांतरण के लिए गद्य त्रुटि प्रवण हैं।

vkarpov15 27 अग॰ 2017

😄1

नमस्ते, मैं नेवला का उपयोग कर रहा हूँ 4.6.5 और अभी भी इन समाधानों के साथ एक खाली सरणी को बचाने के लिए।

services: [{ type: Schema.Types.ObjectId, ref: 'Service', default: () => null }],

services: [{ type: Schema.Types.ObjectId, ref: 'Service', default: void 0 }],

killboard 13 दिस॰ 2017

@keyboard99 कृपया https://github.com/Automattic/mongoose/issues/1335#issuecomment -252129243 में दिए गए निर्देशों का पालन

vkarpov15 18 दिस॰ 2017

👍1

उन मुद्दों का एक सरल समाधान है। अपरिभाषित के रूप में बस डिफ़ॉल्ट मान प्रदान करें। निम्नलिखित अनुसार:

var BarSchema = new Schema({
    foos: {
        type: [FooSchema],
        default: undefined
    }
});

मेरे लिये कार्य करता है

KErez 21 मार्च 2018

👍6 🚀2 🎉2

लेकिन इससे array.push के साथ जटिलताएं पैदा होंगी
:(

GeneralG 21 मार्च 2018

@GeneralG किसी भी होने का स्पष्ट एक के अलावा अन्य जटिलताओं करने के लिए doc.array = doc.array || []; कॉल करने से पहले push() ?

vkarpov15 27 मार्च 2018

👍3

क्या यह पृष्ठ उपयोगी था?

0 / 5 - 0 रेटिंग्स

Mongoose: जब कोई संपत्ति किसी स्कीमा का संदर्भ देती है तो खाली सरणी सहेजी जाती है

सबसे उपयोगी टिप्पणी

सभी 39 टिप्पणियाँ

संबंधित मुद्दों