Come ottenere i metodi di un oggetto?

Esiste un metodo o una proprietà per ottenere tutti i metodi da un oggetto? Per esempio:

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

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

AGGIORNAMENTO: esiste un metodo simile in Jquery?

Grazie.

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

Ricorda che tecnicamente gli oggetti javascript non hanno metodi. Hanno proprietà, alcune delle quali possono essere oggetti funzione. Ciò significa che puoi enumerare i metodi in un oggetto proprio come puoi enumerare le proprietà. Questo (o qualcosa di simile a questo) dovrebbe funzionare:

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

Ci sono delle complicazioni perché alcune proprietà degli oggetti non sono enumerabili, quindi non sarai in grado di trovare tutte le funzioni dell'oggetto.

È possibile utilizzare console.dir(object)per scrivere le proprietà degli oggetti nella console.

Nei browser moderni è possibile utilizzare Object.getOwnPropertyNamesper ottenere tutte le proprietà (sia enumerabili che non enumerabili) su un oggetto. Per esempio:

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

Si noti che questo recupera solo le proprietà proprie , quindi non restituirà le proprietà trovate altrove nella catena del prototipo. Questa, tuttavia, non sembra essere la tua richiesta, quindi presumo che questo approccio sia sufficiente.

Se desideri visualizzare solo proprietà enumerabili , puoi invece utilizzare Object.keys. Ciò restituirà la stessa raccolta, meno la constructorproprietà non enumerabile .

I metodi possono essere controllati nella catena del prototipo dell'oggetto utilizzando gli strumenti di sviluppo del browser (F12):

  console.log(yourJSObject);

o più direttamente

  console.dir(yourJSObject.__proto__);

In 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"]

per me, l'unico modo affidabile per ottenere i metodi della classe di estensione finale, era fare in questo modo:

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

Sono su un telefono senza punto e virgola :) ma questa è l'idea generale.

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

Puoi semplicemente eseguire il loop sul prototipo di un costruttore ed estrarre tutti i metodi.

il modo migliore è:

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

usa 'let' solo in es6, usa invece 'var'

In Chrome è keys(foo.prototype). Resi ["a", "b"].

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

Modifica successiva: se devi copiarlo velocemente (per oggetti più grandi), fallo copy(keys(foo.prototype))e lo avrai negli appunti.

Ottieni i nomi dei metodi:

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

Oppure, ottieni i metodi:

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