Question

让我们解决这个问题，我需要删除对象中的所有函数，以通过socket.io JSON发送！假设我有一个对象，例如...

let myObject = {
    test1: "abc",
    test2: function() {
        console.log("This is a function");
    },
    test3: {
        test4: "another string",
        test5: function() {
            console.log("another function");
        },
        test6: 123
    }
}

我也需要转换

let myObject = {
    test1: "abc",
    test3: {
        test4: "another string",
        test6: 123
    }
}

我尝试了许多鳕鱼方法，但都失败了！我会发布它们，但这将浪费您的宝贵时间。我很乐意以一种精巧的功能解决此问题的任何人。真的，雅各布·莫里斯（Jacob Morris）

P.S。这是进行此操作的c ** p次尝试

let myObject = {
  test1: "abc",
  test2: function() {
      console.log("This is a function");
  },
  test3: {
      test4: "another string",
      test5: function() {
          console.log("another function");
      },
      test6: 123
  }
}

let i = [];
function tsfr(ls) {
    let i = {};
    for (let a in ls) {
        if (typeof(ls[a]) !== "function") {
            let d = ls[a];
            if (typeof(d) == "object") {
                d = tsfr(d);
            }
            i[a] = d;
        }
    }
    return i;
}
i = tsfr(myObject);
console.log(i)

Answer 1

您可以编写自己的递归解决方案，但我认为最好使用JSON.stringify。默认情况下，stringify会忽略函数并将其从结果中删除。在某些情况下，第二个参数是替换函数，可以方便地进行更高级的对象操作。

const removeFunctions = (obj) => {
  const stringified = JSON.stringify(obj);

  // We need to parse string back to object and return it
  const parsed = JSON.parse(stringified);

  return parsed;
}

const myObject = {
    test1: "abc",
    test2: function() {
        console.log("This is a function");
    },
    test3: {
        test4: "another string",
        test5: function() {
            console.log("another function");
        },
        test6: 123
    }
}

console.log(removeFunctions(myObject));

（或在codepen上）

请注意，字符串化使用toString()方法，对于某些自定义类实例，可能会导致数据丢失。为避免这种情况，您需要编写自己的递归解决方案。它可能会变得更加复杂。

希望这会有所帮助，加油！

编辑：我刚刚看到了您的尝试。这是朝正确方向迈出的一步，但还需要更多的爱。但我需要建议您不要使用变量名，例如tsfr或ls。如果您使用更长的，更具描述性的名称，则代码更易读。

EDIT2：正如Andreas在评论中指出的那样，您甚至不需要自定义替换器，因为stringify会忽略它们并默认将其删除。

Answer 2

您可以使用delete并递归地删除嵌套对象属性，如下所示：

let myObject = {
  test1: "abc",
  test2: function() {
    console.log("This is a function");
  },
  test3: {
    test4: "another string",
    test5: function() {
      console.log("another function");
    },
    test6: 123
  }
}

const deleteFunctions = (obj) => {
  Object.keys(obj).forEach(k => {
    if (typeof obj[k] === "function")
      delete obj[k];
    else if (typeof obj[k] === "object")
      deleteFunctions(obj[k])
  })
}

deleteFunctions(myObject)

console.log(myObject)

Answer 3

您可以通过类型检查来过滤键/值对，然后通过检查嵌套对象来映射新对象。

const
    removeFn = object => Object.assign(...Object
        .entries(object).filter(([k, v]) => typeof v !== 'function')
        .map(([k, v]) => ({ [k]: v && typeof v === 'object' ? removeFn(v) : v }))
    );

var object = { test1: "abc", test2: function() { console.log("This is a function"); }, test3: { test4: "another string", test5: function() { console.log("another function"); }, test6: 123 } };

console.log(removeFn(object));

Answer 4

只是为了好玩，我会这样做。这是对Douglas Crockford的DOM算法的重新审视。

首先，一个访问任意对象并对每个成员应用任意函数的递归函数（visit()）：

function visit(obj, func)
{
  for (k in obj)
  {
    func(obj, k);

    if (typeof obj[k] === "object")
    {
      visit(obj[k], func);
    }
  }
}

这是一个带有有效负载功能的工作示例，该功能仅将找到的功能输出到控制台：

var testdata = {
  "a": 1,
  "b": "hello",
  "c": [ 1, 2, 3 ],
  "d": (x) => 2 * x,
  "e": null,
  "f": {
    "x": 10,
    "y": {
      "z": "$$$",
      "zz": (x) => 0
    }
  }
};

function visit(obj, func)
{
  for (k in obj)
  {
    func(obj, k);
    
    if (typeof obj[k] === "object")
    {
      visit(obj[k], func);
    }
  }
}

visit(testdata, (obj, k) => {
  if (typeof obj[k] === "function")
  {
    console.log(k + " is a function");
  }
});

如上面的代码所示，有效载荷函数func能够找到对象中的所有且唯一的函数。

我们现在需要的是一个删除成员的函数，但是现在这很简单：

(obj, k) => {
  if (typeof obj[k] === "function")
  {
    delete obj[k];
  }
}

通过将访问与有效负载分开，您可以以多种方式重用此访问，并为各种必需品递归操作对象...

Answer 5

它将删除上述对象中的所有功能

function removeFuncFromObj(obj) {
  Object.keys(obj).map((key) => {
    if (typeof obj[key] === "function") {
        delete obj[key];
    }
    if (typeof obj[key] === typeof {}) {
        removeFuncFromObj(obj[key]);
    }
  });
  return obj;
}
removeFuncFromObj(myObject);

[https://jsbin.com/favikej/edit?js,console,output][1]

如何循环对象并从中删除所有功能

5 个答案: