javascript - 如何在 API 调用后比较两个对象的值，检查空值或空值

Question

我有一个在 API 调用后修改的原始对象。我需要确保将原本不为空的任何字段重新分配为其原始值。例如，如果 articleTitle 最初是填写的，然后在 API 调用后它被替换为一个空值，我想将它重新分配回原始的 articleTitle 值旧对象。

这两个对象具有相同的键，但我不能假设从响应返回的数据总是有效的(但原始对象始终具有有效数据，这就是我需要重新分配任何空字段的原因到原始值)。

我(有点)有一个理论上可行的方法，但是我想知道是否有更有效的方法来做到这一点。这是我拥有的:

function evaluateEmptyValues = (originalReference, reference) {
    // Get keys of both reference objects
    var newReference = Object.entries(reference);
    var oldReference = Object.entries(originalReference);

    // Get length of both reference objects
    var newReferenceLength = newReference.length;
    var oldReferenceLength = oldReference.length;

    // Double check objects are of the same length -- they always should be
    if (newReferenceLength == oldReferenceLength) {
        // Cycle through both objects
        for (var i = 0; i < newReference.length; i++) {
            console.log('i is ' + i);

            // Again, these two lengths should be equal
            if (newReference[i].length == oldReference[i].length) {
                // Check if elements in current iteration is an object --
                // if one is an object, then the other SHOULD also be
                if ((typeof(newReference[i][j]) == 'object' &&
                    typeof(oldReference[i][j]) == 'object'
                ) {
                    // If both are objects, repeat lines 3 and 4
                    var currentNewReference = Object.entries(newReference[i][j]);
                    var currentOldReference = Object.entries(oldReference[i][j]);

                    // Get their lengths
                    var currentNewReferenceLength = currentNewReference.length;
                    var currentOldReferenceLength = currentOldReference.length;

                    // Both should be of the same length
                    if (currentNewReferenceLength == currentOldReferenceLength) {
                        for (var io = 0; io < currentNewReferenceLength.length; io++) {
                            console.log('io is ' + io);

                            // Both should also be of the same length
                            if (currentNewReference[io].length == currentOldReference[io].length) {
                                // For each iteration...
                                for (var jo = 0; jo < currentNewReference[io].length; jo++) {
                                    // Check for empty values
                                    if (currentNewReference[io][jo] == undefined ||
                                        currentNewReference[io][jo] == null ||
                                        (typeof(currentNewReference[io][jo]) == 'string' && currentNewReference[io][jo].trim() == '')
                                    ) {
                                        // If empty, then reassign the empty value in the new reference
                                        // object with the value of the field from the old reference
                                        // object, regardless of whether or not the old value is also empty/null
                                        currentNewReference[io][jo] = currentOldReference[io][jo];
                                    }
                                }
                            } else {
                                // Serious problem
                            }
                        }
                    } else {
                        // Serious problem
                    }
                } else {
                    // Cycle through current field
                    for (var j = 0; j < newReference[i].length; j++) {
                        // Check for nulls or empties
                        if (newReference[i][j] == undefined ||
                            newReference[i][j] == null ||
                            (typeof(newReference[i][j]) == 'string' && newReference[i][j].trim() == '')
                        ) {
                            // Assign old value to new value, regardless of
                            // whether or not old value is also empty
                            newReference[i][j] = oldReference[i][j];
                        }
                    }
                }
            } else {
                // Serious problem
            }
        }
    } else {
        // Serious problem
    }

我怀疑这是一种非常可扩展或可维护的方法，我想知道是否有任何关于增强此功能的建议，最好使用 ES5，除非 ES6+ 版本适用于大多数浏览器。

---

作为引用，这里有两个对象:

这里，articleTitle 是空的。

此处，它是通过 API 调用填写的。这是预期和需要的，但是想象一下，如果它是相反的，并且 articleTitle 在 API 调用后在 newReference 中返回为空

---

编辑:

使用接受的答案加上调整，这解决了我的具体问题:

function evaluateEmptyValues(reference, originalReference) {
    var vm = this;

    // Get keys and values of both reference objects
    referenceLength = Object.entries(reference).length;
    originalReferenceLength = Object.entries(originalReference).length;

    if (referenceLength == originalReferenceLength) {
        try {
            // Cycle through both objects
            for (var prop in reference) {
                    if (reference[prop] != undefined || reference[prop] != null) {
                        if (typeof (reference[prop]) == 'string' && reference[prop].trim() != '') {
                            // If both current elements are objects, recurse
                            if (typeof reference[prop] == 'object' && typeof originalReference[prop] == 'object') {
                                vm.evaluateEmptyValues(reference[prop], originalReference[prop])
                            }
                            // If both current elements are arrays, recurse
                            if (Array.isArray(reference[prop]) && typeof Array.isArray(originalReference[prop])) {
                                reference[prop].forEach((item, index) => vm.evaluateEmptyValues(item, originalReference[prop][index]));
                            }
                            // If new value is null, empty or undefined, assign it to old value,
                            // regardless of whether or not the old value was also null/empty.
                            //
                            ///// This is to ensure that no existing previous values are
                            ///// overwritten with any nulls or empty values
                        } else {
                            reference[prop] = originalReference[prop];
                        }
                } else {
                    reference[prop] = originalReference[prop];
                }
            }
        } catch(err) {
            console.log(err);
        }
    }

    console.log(reference);

Answer 1

您可以使用递归和 for ... in 循环大大简化您的函数。我制作了两个测试对象来说明您原始示例的所有情况。如果它命中一个对象数组，它将遍历该数组并递归地检查空值。请看下面的片段:

function evaluateEmptyValues(reference, originalReference) {
  if (reference.length == originalReference.length) {
    for (var prop in reference) {
      if (typeof reference[prop] == 'object' && typeof originalReference[prop] == 'object') {
        evaluateEmptyValues(reference[prop], originalReference[prop])
      }
      if (Array.isArray(reference[prop]) && typeof Array.isArray(originalReference[prop])) {
        reference[prop].forEach((item, index) => evaluateEmptyValues(item, originalReference[prop][index]));
      }
      if (reference[prop] == undefined || reference[prop] == null ||
        (typeof (reference[prop]) == 'string' && reference[prop].trim() == '')) {
        reference[prop] = originalReference[prop];
      }
    }
  }
}

const original = {
  name: "Jack",
  employee: {
    firstName: "Nathan",
    favoriteAnimal: {
      species: "Donkey",
      nature: "Lazy"
    },
    favoriteBeverages: [
      { name: "Beer", temperature: "Cold" },
      { name: "More beer", temperature: "Colder" }
    ]
  },
  occupation: "Plumber"
}

const newObject = {
  name: "Jack",
  employee: {
    firstName: " ",
    favoriteAnimal: {
      species: null,
      nature: "Lazy"
    },
    favoriteBeverages: [
      { name: "Beer", temperature: ""},
      { name: null, temperature: "Colder" }
    ]
  },
  occupation: undefined
}

evaluateEmptyValues(newObject, original);
console.log(newObject);