检查某些 Javascript 对象键是否具有精确的嵌套值，然后更新特定的嵌套值

Question

I have a Javascript object that can have either none, one, or multiple keys. Then each key has a nested value.

Example

cart = {
    "98eb9514-f403-4d08-b5f7-dd6a5ec013cb": {
        "quantity": 1,
        "FirstName": "John",
        "LastName": "Lewis"
    },
    "92ef2918-6bc2-4f3b-b9b3-acf6ebe74b1f": {
        "quantity": 1,
        "FirstName": "Matthew",
        "LastName": "Smith"
    }
}

I need to check if a key has an exact nested value. If it does, then I need to add 1 to the quantity for that exact key with that exact nested value.

I am able to check if an exact key with that exact nested value exist by doing:

if (cart.hasOwnProperty(productId) &&
    cart[productId]["quantity"] >= 1 &&
    cart[productId]["FirstName"] == FirstName &&
    cart[productId]["LastName"] == LastName) {
    console.log('add one to qty somehow...')
}

However, this seems very inefficient and then I can't even figure out a way to add one to the quantity for just that exact key with that exact nested value.

If it is not clear, my question comes down to this: How do I check if a key with an exact nested value exist, and if it does, how do I add 1 to the quantity for that same exact key/nested value.

Been working on this for a day and half. Any help is much appreciated.

Answer 1

You could do it like this:

 const cart = { "98eb9514-f403-4d08-b5f7-dd6a5ec013cb":{"quantity":1,"FirstName":"John", "LastName":"Lewis"}, "92ef2918-6bc2-4f3b-b9b3-acf6ebe74b1f":{"quantity":1,"FirstName":"Matthew", "LastName":"Smith"} } const productId = "92ef2918-6bc2-4f3b-b9b3-acf6ebe74b1f"; const firstName = "Matthew"; const lastName = "Smith"; const quantity = 1; const cartItem = cart[productId]; if(typeof cartItem !== "undefined" && cartItem.FirstName === firstName && cartItem.LastName === lastName && cartItem.quantity >= 1) { cartItem.quantity += 1; }; console.log(cart);

Once you have a handle on the intended cart property, you can simply increment its quantity property.

Answer 2

 let cart = { "98eb9514-f403-4d08-b5f7-dd6a5ec013cb": { "quantity": 1, "FirstName": "John", "LastName": "Lewis" }, "92ef2918-6bc2-4f3b-b9b3-acf6ebe74b1f": { "quantity": 1, "FirstName": "Matthew", "LastName": "Smith" } } let productId = '98eb9514-f403-4d08-b5f7-dd6a5ec013cb'; // any product key let valueToMAtch = 1; // any value to match let productKey = Object.keys(cart).find((key) => key === productId); Object.entries(cart[productKey] || {}).forEach(([key, value]) => { // || {} allows undefined handing if no product is found if (value === valueToMAtch) { cart[productKey][key] += 1; // adding one } }); console.log(cart); // result

Answer 3

If you're comparing thousands of records to thousands of other records, might want to pack it up somehow - the intent here, though, is it to de-dupe?

If so, you could try something like...

var cartCounter = {};
for (var itemKey in cart) {
 var item = cart[itemKey];
 var key = item.FirstName + "|" + item.LastName;
 if (!cartCounter[key]) {
  cartCounter[key] = item;
 } else {
  cartCounter[key].quantity++;
 }
}

Answer 4

If you need deep equality based on enumerable properties only (that is: the values that you get when you use for...of , or Object.keys , etc.) then you can determine equality based on the JSON serialization of those objects, provided you force key sorting , using the rarely talked about replacer argument for JSON.stringify() .

This is an incredibly powerful feature of the JSON serialization process, and we can write a simple function that will guarantee any object we pass in will always serialize to the same JSON string, regardless of key ordering at any depth:

function sortedObjectKeys(_, data) {
  // Ignore primitives.
  if (data === null) return null;
  if (typeof data !== "object") return data;

  // Also ignore iterables, which are type "object" but
  // should not be sorted because [1,2,3] is not [1,3,2].
  if (data.__proto__[Symbol.iterator]) return data;

  // Then sort the object keys and yield a new object with that
  // ordering enforced by key insertion.
  return Object.fromEntries(Object.entries(data).sort());
}

We can now perform a deep equality test using string equality:

function deepEqual(o1, o2) {
  const s1 = JSON.stringify(o1, sortedObjectKeys);
  const s2 = JSON.stringify(o2, sortedObjectKeys);
  return s1 === s2;
}