Comment obtenir les méthodes d'un objet?

Existe-t-il une méthode ou une propriété pour obtenir toutes les méthodes d'un objet? Par exemple:

function foo() {}
foo.prototype.a = function() {}
foo.prototype.b = function() {}

foo.get_methods(); // returns ['a', 'b'];

MISE À JOUR: Y a-t-il une méthode comme celle-là dans Jquery?

Je vous remercie.

function getMethods(obj)
{
    var res = [];
    for(var m in obj) {
        if(typeof obj[m] == "function") {
            res.push(m)
        }
    }
    return res;
}

Rappelez-vous que techniquement, les objets javascript n'ont pas de méthodes. Ils ont des propriétés, dont certaines peuvent être des objets de fonction. Cela signifie que vous pouvez énumérer les méthodes dans un objet tout comme vous pouvez énumérer les propriétés. Ceci (ou quelque chose de proche) devrait fonctionner:

var bar
for (bar in foo)
{
    console.log("Foo has property " + bar);
}

Il y a des complications à cela car certaines propriétés des objets ne sont pas énumérables et vous ne pourrez donc pas trouver toutes les fonctions de l'objet.

Vous pouvez utiliser console.dir(object)pour écrire les propriétés des objets dans la console.

Dans les navigateurs modernes, vous pouvez utiliser Object.getOwnPropertyNamespour obtenir toutes les propriétés (énumérables et non énumérables) sur un objet. Par exemple:

function Person ( age, name ) {
    this.age = age;
    this.name = name;
}

Person.prototype.greet = function () {
    return "My name is " + this.name;
};

Person.prototype.age = function () {
    this.age = this.age + 1;
};

// ["constructor", "greet", "age"]
Object.getOwnPropertyNames( Person.prototype );

Notez que cela ne récupère que les propriétés propres , donc il ne retournera pas les propriétés trouvées ailleurs sur la chaîne de prototypes. Cependant, cela ne semble pas être votre demande, je suppose donc que cette approche est suffisante.

Si vous souhaitez uniquement voir les propriétés énumérables , vous pouvez utiliser à la place Object.keys. Cela renverrait la même collection, moins la constructorpropriété non énumérable .

Les méthodes peuvent être inspectées dans la chaîne prototype de l'objet à l'aide des outils de développement du navigateur (F12):

  console.log(yourJSObject);

ou plus directement

  console.dir(yourJSObject.__proto__);

Dans ES6:

let myObj   = {myFn : function() {}, tamato: true};
let allKeys = Object.keys(myObj);
let fnKeys  = allKeys.filter(key => typeof myObj[key] == 'function');
console.log(fnKeys);
// output: ["myFn"]

pour moi, le seul moyen fiable d'obtenir les méthodes de la classe d'extension finale, était de faire comme ceci:

function getMethodsOf(obj){
  const methods = {}
  Object.getOwnPropertyNames( Object.getPrototypeOf(obj) ).forEach(methodName => {
    methods[methodName] = obj[methodName]
  })
  return methods
}

var funcs = []
for(var name in myObject) {
    if(typeof myObject[name] === 'function') {
        funcs.push(name)
    }
}

Je suis sur un téléphone sans point virgule :) mais c'est l'idée générale.

var methods = [];
for (var key in foo.prototype) {
    if (typeof foo.prototype[key] === "function") {
         methods.push(key);
    }
}

Vous pouvez simplement boucler sur le prototype d'un constructeur et extraire toutes les méthodes.

le meilleur moyen est:

let methods = Object.getOwnPropertyNames(yourobject);
console.log(methods)

utilisez 'let' uniquement dans es6, utilisez 'var' à la place

Dans Chrome est keys(foo.prototype). Retours ["a", "b"].

Voir: https://developer.chrome.com/devtools/docs/commandline-api#keysobject

Edition ultérieure: si vous avez besoin de le copier rapidement (pour des objets plus gros), faites-le copy(keys(foo.prototype))et vous l'aurez dans le presse-papiers.

Obtenez les noms de méthode:

var getMethodNames = function (obj) {
    return (Object.getOwnPropertyNames(obj).filter(function (key) {
        return obj[key] && (typeof obj[key] === "function");
    }));
};

Ou, obtenez les méthodes:

var getMethods     = function (obj) {
    return (Object.getOwnPropertyNames(obj).filter(function (key) {
        return obj[key] && (typeof obj[key] === "function");
    })).map(function (key) {
        return obj[key];
    });
};