Obtener el nombre del objeto o clase

¿Hay alguna solución para obtener el nombre de la función de un objeto?

function alertClassOrObject (o) {
   window.alert(o.objectName); //"myObj" OR "myClass" as a String
}

function myClass () {
   this.foo = function () {
       alertClassOrObject(this);
   }
}

var myObj = new myClass();
myObj.foo();

for (var k in this) {...}- no hay información sobre el classNameo ObjectName. ¿Es posible obtener uno de ellos?

Obtenga la función constructora de su objeto y luego inspeccione su propiedad de nombre .

myObj.constructor.name

Devuelve "myClass".

Ejemplo:

function Foo () { console.log('Foo function'); }
var Bar = function () { console.log('Bar function'); };
var Abc = function Xyz() { console.log('Abc function'); };

var f = new Foo();
var b = new Bar();
var a = new Abc();

console.log('f', f.constructor.name); // -> "Foo"
console.log('b', b.constructor.name); // -> "Function"
console.log('a', a.constructor.name); // -> "Xyz"

Si usa el estándar IIFE (por ejemplo, con TypeScript)

var Zamboch;
(function (_Zamboch) {
    (function (Web) {
        (function (Common) {
            var App = (function () {
                function App() {
                }
                App.prototype.hello = function () {
                    console.log('Hello App');
                };
                return App;
            })();
            Common.App = App;
        })(Web.Common || (Web.Common = {}));
        var Common = Web.Common;
    })(_Zamboch.Web || (_Zamboch.Web = {}));
    var Web = _Zamboch.Web;
})(Zamboch || (Zamboch = {}));

podrías anotar los prototipos por adelantado con

setupReflection(Zamboch, 'Zamboch', 'Zamboch');

y luego use los campos _fullname y _classname.

var app=new Zamboch.Web.Common.App();
console.log(app._fullname);

función de anotación aquí:

function setupReflection(ns, fullname, name) {
    // I have only classes and namespaces starting with capital letter
    if (name[0] >= 'A' && name[0] <= 'Z') {
        var type = typeof ns;
        if (type == 'object') {
            ns._refmark = ns._refmark || 0;
            ns._fullname = fullname;
            var keys = Object.keys(ns);
            if (keys.length != ns._refmark) {
                // set marker to avoid recusion, just in case 
                ns._refmark = keys.length;
                for (var nested in ns) {
                    var nestedvalue = ns[nested];
                    setupReflection(nestedvalue, fullname + '.' + nested, nested);
                }
            }
        } else if (type == 'function' && ns.prototype) {
            ns._fullname = fullname;
            ns._classname = name;
            ns.prototype._fullname = fullname;
            ns.prototype._classname = name;
        }
    }
}

JsFiddle

Como esto ya fue respondido, solo quería señalar las diferencias en los enfoques para obtener el constructor de un objeto en JavaScript. Hay una diferencia entre el constructor y el nombre real del objeto / clase. Si lo siguiente se suma a la complejidad de su decisión, entonces tal vez esté buscando instanceof. O tal vez deberías preguntarte "¿Por qué estoy haciendo esto? ¿Es esto realmente lo que estoy tratando de resolver?"

Notas:

El obj.constructor.nameno está disponible en navegadores antiguos. La coincidencia (\w+)debe satisfacer las clases de estilo ES6.

Código:

var what = function(obj) {
  return obj.toString().match(/ (\w+)/)[1];
};

var p;

// Normal obj with constructor.
function Entity() {}
p = new Entity();
console.log("constructor:", what(p.constructor), "name:", p.constructor.name , "class:", what(p));

// Obj with prototype overriden.
function Player() { console.warn('Player constructor called.'); }
Player.prototype = new Entity();
p = new Player();
console.log("constructor:", what(p.constructor), "name:", p.constructor.name, "class:", what(p));

// Obj with constructor property overriden.
function OtherPlayer() { console.warn('OtherPlayer constructor called.'); }
OtherPlayer.constructor = new Player();
p = new OtherPlayer();
console.log("constructor:", what(p.constructor), "name:", p.constructor.name, "class:", what(p));

// Anonymous function obj.
p = new Function("");
console.log("constructor:", what(p.constructor), "name:", p.constructor.name, "class:", what(p));

// No constructor here.
p = {};
console.log("constructor:", what(p.constructor), "name:", p.constructor.name, "class:", what(p));

// ES6 class.
class NPC { 
  constructor() {
  }
}
p = new NPC();
console.log("constructor:", what(p.constructor), "name:", p.constructor.name , "class:", what(p));

// ES6 class extended
class Boss extends NPC {
  constructor() {
    super();
  }
}
p = new Boss();
console.log("constructor:", what(p.constructor), "name:", p.constructor.name , "class:", what(p));

Resultado:

Código: https://jsbin.com/wikiji/edit?js,console

Me enfrentaba a una dificultad similar y ninguna de las soluciones presentadas aquí era óptima para lo que estaba trabajando. Lo que tenía era una serie de funciones para mostrar contenido en un modo y estaba tratando de refactorizarlo bajo una única definición de objeto haciendo las funciones, métodos de la clase. El problema surgió cuando descubrí que uno de los métodos creaba algunos botones de navegación dentro del modal que usaban un onClick para una de las funciones, ahora un objeto de la clase. He considerado (y sigo considerando) otros métodos para manejar estos botones de navegación, pero pude encontrar el nombre de la variable para la clase barriendo las variables definidas en la ventana principal. Lo que hice fue buscar cualquier cosa que coincida con la 'instancia de' mi clase, y en caso de que haya más de una,

var myClass = function(varName)
{
    this.instanceName = ((varName != null) && (typeof(varName) == 'string') && (varName != '')) ? varName : null;

    /**
     * caching autosweep of window to try to find this instance's variable name
     **/
    this.getInstanceName = function() {
        if(this.instanceName == null)
        {
            for(z in window) {
                if((window[z] instanceof myClass) && (window[z].uniqueProperty === this.uniqueProperty)) {
                    this.instanceName = z;
                    break;
                }
            }
        }
        return this.instanceName;
    }
}

Prueba esto:

var classname = ("" + obj.constructor).split("function ")[1].split("(")[0];

Todo lo que necesitamos:

1. Envuelva una constante en una función (donde el nombre de la función es igual al nombre del objeto que queremos obtener)
2. Usar funciones de flecha dentro del objeto

console.clear();
function App(){ // name of my constant is App
  return {
  a: {
    b: {
      c: ()=>{ // very important here, use arrow function 
        console.log(this.constructor.name)
      }
    }
  }
}
}
const obj = new App(); // usage

obj.a.b.c(); // App

// usage with react props etc, 
// For instance, we want to pass this callback to some component

const myComponent = {};
myComponent.customProps = obj.a.b.c;
myComponent.customProps(); // App