如何在插入文档时清理对象？求替代Meteor simple-schema的实现方法

I get it—you're looking to replicate the auto-cleaning behavior of Meteor's simple-schema where null values and empty strings ("") are stripped from documents before insertion, and you haven't been able to find the right solution because you might have been using the wrong terminology. Let's fix that and walk through how to implement this.

First, let's clarify the exact functionality you need: removing object properties that have values of null or empty strings ("") (shallowly or deeply, depending on your use case). This is the key term to search for if you want more variations on this solution.

Shallow Clean (Only Top-Level Properties) #

If you just need to clean the first level of your object (no nested objects), this simple function will work:

function cleanObject(obj) {
  const cleaned = {};
  for (const key in obj) {
    const value = obj[key];
    // Keep properties that are not null and not empty strings
    if (value !== null && value !== "") {
      cleaned[key] = value;
    }
  }
  return cleaned;
}

// Example usage
const originalDoc = { "_id": "f3iujiimjHo4m3Cqj", "monday": true, "tuesday": "" };
const cleanedDoc = cleanObject(originalDoc);
console.log(cleanedDoc); // Output: { "_id": "f3iujiimjHo4m3Cqj", "monday": true }

Deep Clean (Including Nested Objects/Arrays) #

If your documents have nested objects or arrays that also need cleaning, use this recursive version:

function deepCleanObject(obj) {
  // Return non-object values as-is (unless they're null/empty string)
  if (typeof obj !== 'object' || obj === null) {
    return obj;
  }

  // Handle arrays: clean each item and filter out null/empty string values
  if (Array.isArray(obj)) {
    return obj
      .map(item => deepCleanObject(item))
      .filter(item => item !== null && item !== "");
  }

  // Handle objects: iterate through keys and clean each value
  const cleaned = {};
  for (const key in obj) {
    const cleanedValue = deepCleanObject(obj[key]);
    if (cleanedValue !== null && cleanedValue !== "") {
      cleaned[key] = cleanedValue;
    }
  }
  return cleaned;
}

// Example usage with nested data
const nestedDoc = { 
  "_id": "abc123", 
  "monday": true, 
  "tuesday": "",
  "details": {
    "time": null,
    "location": "office"
  },
  "reminders": ["", "meeting", null]
};
const cleanedNested = deepCleanObject(nestedDoc);
console.log(cleanedNested); 
// Output: { "_id": "abc123", "monday": true, "details": { "location": "office" }, "reminders": ["meeting"] }

Integrating with Database Insertions #

If you're using a database library (like Mongoose for MongoDB), you can hook this cleaning logic into pre-save or pre-insert hooks to automate it:

// Example with Mongoose Schema
const yourSchema = new mongoose.Schema({ /* your schema definition */ });

yourSchema.pre('save', function(next) {
  // Clean the object before saving
  const cleaned = cleanObject(this.toObject());
  this.set(cleaned);
  next();
});

For frontend use cases (like preparing data before sending to an API), just call the cleaning function right before you submit the data.

The key takeaway here is that this is a common object manipulation task—searching for terms like "remove null empty string properties from object" or "clean object before insertion" will lead you to more tailored solutions if you need adjustments for specific frameworks or edge cases.

内容的提问来源于stack exchange，提问作者bp123