更新动态数据中对象或数组中的所有值字符串

Question

我需要验证、更新、转义数据对象中的对象或数组中的每个值字符串，数据总是改变这个基本方案。我的这段代码正在运行，可以做得更好或减少递归深度吗？

let data = {
  "data": "general",
  "another" : ["fbdfdfdfdfdfdfdfdf", "somestring2"],
  "MyStringArray" : ["valid_type.pathdir", "/pathdir/desdss"],
  "html_data":  [
      {
      "data": [
          {
            "item_title": "Server Version:",
          },
          ["fbdfdfdfdfdfdfdfdf", "somestring2"],
          {
            "value_title": "2.0.1"
          }
        ]
      },
      {
      "head_title": "Info app",
      "data": [
          {
            "value_title": "1.0.1"
          },
          {
            "item_title": "javascript Version:",
          }
        ]
      }
  ]
};
    
let counter = 0
let limit_recursion = 150

    
function funct(object) {

  if ( counter > limit_recursion ) {
    throw new Error("limit exceeded, maximum recursion allowed is " + limit_recursion );
  }
  

  for ( let key in object ) {

    if (typeof object[key] === "string") {
      object[key] = validate_escape(object[key]);
    }
    else if ( _has_array_to_validate_get_string(object[key]) ) { // ["valid_type.pathdir", "/pathdir/desdss"],

      object[key][1] = validate_escape(object[key][0], object[key][1]);

    }
    else if ( Array.isArray(object[key]) && object[key].every(item => typeof item === "string")  ) {

      object[key].forEach((value, index) => {
        object[key][index] = validate_escape(value);
      });

    }
    else if ( Array.isArray(object[key]) && object[key].every(    item => typeof item === "object" && !Array.isArray(item)     )  ) {

      object[key].forEach((value) => {
        funct(value);
      });

    }
    else if (typeof object[key] === 'object' && !Array.isArray(object[key]) ) {

      funct(object[key])

    }
    else if ( Array.isArray(object[key] ) ) {

      funct(object[key])

    }

      counter++;
  }

  return object;

}

关于这里的

_has_array_to_validate_get_string

我使用了一个数组来存储键和值来检测类型字符串验证。 关于

validate_escape

，是内部类，用于进行验证、更新、转义。

function _has_array_to_validate_get_string(array) {
  return Array.isArray(array) && array.length === 2 && typeof array[0] === "string" && array[0].includes('valid_type');
}

function validate_escape(var1, var2) {
  return var1 + var2;
}

Answer 1

注意

：这个答案得到的结果与你问题中的结果相同，但我认为他们两个都可能有问题。它用诸如 "somestring2undefined" 之类的值填充您的对象，并将

"undefined"

附加到几乎所有内容上，因为我们仅使用单个参数调用

validate_escape

。我猜这是一个简单的修复，但我不太了解要求。说到要求，你的问题确实需要一些关注。您发布一个代码块并要求其更好的版本，但您从不解释它的作用，当您真正可以时不包含可运行的代码片段，并且其中存在奇怪的

"undefined"

问题。

使用两个小辅助函数（

---

transform

和

mapObject

），我们可以将您的函数重写为

{test, handle}

对的简单集合，执行单个转换并根据需要重复。上面

funct

的替换看起来像这样：

const funct = transform ([
  {test: (v) => typeof v == 'string', handle: (v) => validate_escape(v)},
  {test: (v) => _has_array_to_validate_get_string(v), handle: ([x, y]) => [x, validate_escape(x, y)]},
  {test: (v) => Array.isArray(v), handle: (v, recur) => v.map(recur)},
  {test: (v) => typeof v == 'object', handle: (v, recur) => mapObject(recur)(v)},
])

mapObject

是一个相当简单的函数，将

map

的概念应用于平面对象，例如，map(n => n * n)({a: 1, b: 2, c: 3, d: 4})

会产生

{a: 1, b : 4, c: 9, d: 16}

重要的函数是 

transform

，它接受具有

test

和

handle

函数的对象数组。它返回一个接受单个值的函数，并遍历这些对象以查找第一个对象，其中使用该值调用其

test

，返回真实结果。然后，它返回使用您的值调用

handle

函数的结果，以及可用于递归调用相同配置的

transform

函数的函数。如果找不到匹配的处理程序，则仅返回输入值。

const transform = (handlers) => (v) =>
  (handlers.find(h => h.test(v)) || ({handle: (r, v) => v})).handle(v, transform(handlers))

const mapObject = (fn) => (o) =>
  Object.fromEntries(Object.entries(o).map(([k, v]) => [k, fn(v)]))

function _has_array_to_validate_get_string(array) {
  return Array.isArray(array) && array.length === 2 && typeof array[0] === "string" && array[0].includes('valid_type');
}

function validate_escape(var1, var2) {
  return var1 + var2;
}

const funct = transform ([
  {test: (v) => typeof v == 'string', handle: (v) => validate_escape(v)},
  {test: (v) => _has_array_to_validate_get_string(v), handle: ([x, y]) => [x, validate_escape(x, y)]},
  {test: (v) => Array.isArray(v), handle: (v, recur) => v.map(recur)},
  {test: (v) => typeof v == 'object', handle: (v, recur) => mapObject(recur)(v)},
])

const data = {data: "general", another: ["fbdfdfdfdfdfdfdfdf", "somestring2"], MyStringArray: ["valid_type.pathdir", "/pathdir/desdss"], html_data: [{data: [{item_title: "Server Version:"}, ["fbdfdfdfdfdfdfdfdf", "somestring2"], {value_title: "2.0.1"}]}, {head_title: "Info app", data: [{value_title: "1.0.1"}, {item_title: "javascript Version:"}]}]}


console.log(funct(data))

.as-console-wrapper {max-height: 100% !important; top: 0}

我们传递给

transform

的前两个帮助器是您的基本情况，处理单个字符串，并在第一个字符串上使用适当的子字符串处理两元素字符串数组。另外两个简单的函数可以在数组和对象上正确地重复出现。

请注意，此版本不会改变您的原始对象（我们不是野蛮人，对吧？），而是返回它的更改后的克隆。