Comment boucler un objet et en supprimer toutes les fonctions

Vous pouvez écrire votre propre solution récursive, mais je pense qu'il est préférable d'utiliser JSON.stringify . Par défaut, stringify ignore les fonctions et les supprime du résultat. Dans certains cas, son deuxième paramètre, la fonction de remplacement, peut s'avérer utile pour une manipulation d'objets plus avancée.

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));

(Ou sur codepen )

Veuillez noter que la stringification utilise la méthode toString () , et pour certaines instances de classes personnalisées peut conduire à une perte de données. Pour éviter cela, vous devrez écrire votre propre solution récursive. Ce sera probablement beaucoup plus compliqué.

J'espère que cela vous aidera, bravo!

EDIT: Je viens de voir votre tentative. C'est un pas dans la bonne direction, mais il faut encore plus d'amour. Mais je dois vous déconseiller les noms de variables comme tsfr ou ls . Le code est beaucoup plus lisible si vous utilisez des noms plus longs et plus descriptifs.

EDIT2: Comme l'a souligné Andreas dans les commentaires, vous n'avez même pas besoin de remplacement personnalisé car stringify les ignore et les supprime par défaut.

Vous pouvez utiliser delete code> et supprimez récursivement les propriétés des objets imbriqués comme ceci:

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)

Vous pouvez filtrer les paires clé / valeur en vérifiant le type et mapper ultérieurement le nouvel objet en vérifiant les objets imbriqués.

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));

Juste pour le plaisir, je le ferais de cette façon. Ceci est une revisitation des algorithmes DOM de Douglas Crockford.

Premièrement, une fonction récursive ( visit () ) qui visite un objet arbitraire et applique une fonction arbitraire à chaque membre:

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

Voici un exemple de travail avec une fonction de charge utile qui affiche simplement les fonctions trouvées sur la console:

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");
  }
});

Comme le montre le code ci-dessus, la fonction de charge utile func est capable de trouver toutes et seulement les fonctions de l'objet.

Tout ce dont nous avons besoin maintenant, c'est d'une fonction qui supprime le membre, mais c'est très facile maintenant:

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

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

En séparant la visite de la charge utile, vous pouvez réutiliser cela de plusieurs façons et manipuler récursivement des objets pour toutes sortes de nécessités ...

Cela supprimera toutes les fonctions de l'objet ci-dessus

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]