使用回调删除嵌套数组内部的item

    removeItem(array, item) {
      for (var i = 0; i < array.length; i++) {
        if (Array.isArray(array[i])) {
          this.removeItem(array[i], item);
        } else if (array[i] == item) {
          array.splice(i, 1);
          i--;
          array[i].patrolBoolean = false;
          array[i].patrol = "";
        }
      }
    },

2、使用回调删除嵌套数组中的对象内的数组为空

    //删除空数组
    removeEmptyObjects(obj) {
      if (Array.isArray(obj)) {
        // 处理数组
        for (let i = obj.length - 1; i >= 0; i--) {
          if (obj[i].length === 0) {
            obj.splice(i, 1);
          } else {
            this.removeEmptyObjects(obj[i]);
          }
        }
      } else if (typeof obj === "object") {
        // 处理对象
        for (let key in obj) {
          if (obj.hasOwnProperty(key)) {
            if (Array.isArray(obj[key]) && obj[key].length === 0) {
              delete obj[key];
              delete obj.rules;
              delete obj.type;
            } else {
              this.removeEmptyObjects(obj[key]);
            }
          }
        }
      }
    },

3、使用回调过滤数组内部的对象内的空数组

    //过滤空对象
    filterEmptyObjects(obj) {
      if (Array.isArray(obj)) {
        // 处理数组
        let result = [];
        for (let i = 0; i < obj.length; i++) {
          const item = this.filterEmptyObjects(obj[i]);
          if (item !== null) {
            result.push(item);
          }
        }
        return result;
      } else if (typeof obj === "object") {
        // 处理对象
        let result = {};
        for (let key in obj) {
          if (obj.hasOwnProperty(key)) {
            const value = this.filterEmptyObjects(obj[key]);
            if (value !== null) {
              result[key] = value;
            }
          }
        }
        if (Object.keys(result).length > 0) {
          return result;
        } else {
          return null;
        }
      } else {
        // 处理其他类型
        return obj;
      }
    },