¿Cómo obtener los métodos de un objeto?

¿Existe un método o propiedad para obtener todos los métodos de un objeto? Por ejemplo:

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

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

ACTUALIZACIÓN: ¿Hay algún método como ese en Jquery?

Gracias.

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

Recuerde que técnicamente los objetos javascript no tienen métodos. Tienen propiedades, algunas de las cuales pueden ser objetos de función. Eso significa que puede enumerar los métodos en un objeto al igual que puede enumerar las propiedades. Esto (o algo parecido a esto) debería funcionar:

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

Esto tiene complicaciones porque algunas propiedades de los objetos no se pueden enumerar, por lo que no podrá encontrar todas las funciones en el objeto.

Puede utilizar console.dir(object)para escribir las propiedades de los objetos en la consola.

En los navegadores modernos, puede usar Object.getOwnPropertyNamespara obtener todas las propiedades (tanto enumerables como no enumerables) de un objeto. Por ejemplo:

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

Tenga en cuenta que esto solo recupera propiedades propias , por lo que no devolverá propiedades encontradas en otros lugares de la cadena de prototipos. Sin embargo, esa no parece ser su solicitud, por lo que asumiré que este enfoque es suficiente.

Si solo desea ver propiedades enumerables , puede usar Object.keys. Esto devolvería la misma colección, menos la constructorpropiedad no enumerable .

Los métodos se pueden inspeccionar en la cadena de prototipos del objeto utilizando las herramientas de desarrollo del navegador (F12):

  console.log(yourJSObject);

o más directamente

  console.dir(yourJSObject.__proto__);

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

para mí, la única forma confiable de obtener los métodos de la clase de extensión final era hacer lo siguiente:

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

Estoy en un teléfono sin punto y coma :) pero esa es la idea general.

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

Simplemente puede recorrer el prototipo de un constructor y extraer todos los métodos.

la mejor forma es:

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

use 'let' solo en es6, use 'var' en su lugar

En Chrome es keys(foo.prototype). Devoluciones ["a", "b"].

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

Edición posterior: si necesitas copiarlo rápido (para objetos más grandes), hazlo copy(keys(foo.prototype))y lo tendrás en el portapapeles.

Obtenga los nombres de los métodos:

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

O bien, obtenga los métodos:

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