Nombre de variable como una cadena en Javascript

¿Hay alguna manera de obtener un nombre de variable como una cadena en Javascript? (como NSStringFromSelectoren cacao )

Me gustaría hacer así:

var myFirstName = 'John';
alert(variablesName(myFirstName) + ":" + myFirstName);

--> myFirstName:John

ACTUALIZAR

Estoy tratando de conectar un navegador y otro programa usando JavaScript. Me gustaría enviar nombres de instancia desde un navegador a otro programa para el método de devolución de llamada:

FooClass = function(){};
FooClass.someMethod = function(json) {
  // Do something
}

instanceA = new FooClass();
instanceB = new FooClass();
doSomethingInAnotherProcess(instanceB); // result will be substituted by using instanceB.someMethod();

...

De otro programa:

evaluateJavascriptInBrowser("(instanceName).someMethod("resultA");");

En PHP: ¿Cómo obtener un nombre de variable como una cadena en PHP?

Por lo general, usaría una tabla hash para una situación en la que desea asignar un nombre a algún valor y poder recuperar ambos.

var obj = { myFirstName: 'John' };
obj.foo = 'Another name';
for(key in obj)
    console.log(key + ': ' + obj[key]);

Como la respuesta de Seth, pero usa en su Object.keys()lugar:

const varToString = varObj => Object.keys(varObj)[0]

const someVar = 42
const displayName = varToString({ someVar })
console.log(displayName)

Puede usar la siguiente solución para resolver su problema:

const myFirstName = 'John'
Object.keys({myFirstName})[0]

// returns "myFirstName"

En ES6, podría escribir algo como:

let myVar = 'something';
let nameObject = {myVar};
let getVarNameFromObject = (nameObject) => {
  for(let varName in nameObject) {
    return varName;
  }
}
let varName = getVarNameFromObject(nameObject);

Realmente no es lo mejor, pero hace el trabajo.

Esto aprovecha la desestructuración de objetos de ES6.

Más información aquí: https://hacks.mozilla.org/2015/05/es6-in-depth-destructuring/

var x = 2;
for(o in window){ 
   if(window[o] === x){
      alert(o);
   }
}

Sin embargo, creo que deberías hacer como "karim79"

Esto funciona para expresiones básicas

const nameof = exp => exp.toString().match(/[.](\w+)/)[1];

Ejemplo

nameof(() => options.displaySize);

Retazo:

var nameof = function (exp) { return exp.toString().match(/[.](\w+)/)[1]; };
var myFirstName = 'Chuck';
var varname = nameof(function () { return window.myFirstName; });
console.log(varname);

Probablemente pop sería mejor que indexar con [0], por seguridad (la variable puede ser nula).

const myFirstName = 'John'
const variableName = Object.keys({myFirstName}).pop();
console.log(`Variable ${variableName} with value '${variable}'`);

// returns "Variable myFirstName with value 'John'"

var somefancyvariable = "fancy";
Object.keys({somefancyvariable})[0];

Esto no se puede convertir en una función, ya que devuelve el nombre de la variable de la función.

// THIS DOESN'T WORK
function getVarName(v) {
    return Object.keys({v})[0];
}
// Returns "v"

Editar: Gracias a @Madeo por señalar cómo convertir esto en una función .

function debugVar(varObj) {
    var varName = Object.keys(varObj)[0];
    console.log("Var \"" + varName + "\" has a value of \"" + varObj[varName] + "\"");
}

Necesitará llamar a la función con una matriz de elementos únicos que contenga la variable. debugVar({somefancyvariable});
Editar: se Object.keyspuede hacer referencia como solo keysen cada navegador en el que lo probé, pero de acuerdo con los comentarios, no funciona en todas partes.

Desde ECMAScript 5.1 puede usar Object.keys para obtener los nombres de todas las propiedades de un objeto.

Aquí hay un ejemplo:

// Get John’s properties (firstName, lastName)
var john = {firstName: 'John', lastName: 'Doe'};
var properties = Object.keys(john);

// Show John’s properties
var message = 'John’s properties are: ' + properties.join(', ');
document.write(message);

Al tener una función, escriba una función que cambie los valores de diferentes variables globales, no siempre es mi nombre, es lo que sea que esté pasando. Prueba esto funcionó para mí.

_{Ejecutar en jsfiddle}

var jack = 'jill';
function window_getVarName(what)
{
  for (var name in window)
  {
    if (window[name]==what)
    return(name);
  }
  return("");
}
document.write(window_getVarName(jack));

Escribirá a la ventana 'jack'.

Puede reflexionar sobre los tipos en JavaScript y obtener el nombre de las propiedades y los métodos, pero lo que necesita es algo como Lambda Expressions Treesen .NET, creo que no es posible debido a la naturaleza dinámica y la falta de un sistema de tipo estático en JavaScript.

Necesitaba esto, no quiero usar objetos, y se me ocurrió la siguiente solución, dando vuelta la pregunta.

En lugar de convertir el nombre de la variable en una cadena, convierto una cadena en una variable.

Esto solo funciona si se conoce el nombre de la variable, por supuesto.

Toma esto:

var height = 120;
testAlert(height);

Esto debería mostrar:

height: 120

Esto se puede hacer así:

function testAlert(ta)
{
    a = window[ta];
    alert(ta + ': ' + a); 
}

var height = 120;
testAlert("height");
// displays: height: 120

Entonces uso la cadena "height"y la convierto en una variable heightusando el window[]comando.

El camino corto que he encontrado hasta ahora para obtener el nombre de las variables como una cadena:

const name = obj => Object.keys(obj)[0];

const whatsMyName = "Snoop Doggy Dogg";

console.log( "Variable name is: " + name({ whatsMyName }) );
//result: Variable name is: whatsMyName

Esto funcionó con Internet Explorer (9, 10 y 11), Google Chrome 5:

   
var myFirstName = "Danilo";
var varName = Object.keys({myFirstName:0})[0];
console.log(varName);

Tabla de compatibilidad del navegador:
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys

He creado esta función basada en JSON como alguien sugirió, funciona bien para mis necesidades de depuración

function debugVar(varNames){
let strX = "";
function replacer(key, value){
    if (value === undefined){return "undef"}
    return value
    }    
for (let arg of arguments){
let lastChar;
    if (typeof arg!== "string"){
        let _arg = JSON.stringify(arg, replacer);
        _arg = _arg.replace('{',"");
        _arg = _arg.replace('}',"");            
        _arg = _arg.replace(/:/g,"=");
        _arg = _arg.replace(/"/g,"");
        strX+=_arg;
    }else{
    strX+=arg;
    lastChar = arg[arg.length-1];
    }
    if (arg!==arguments[arguments.length-1]&&lastChar!==":"){strX+=" "};
}
console.log(strX)    
}
let a = 42, b = 3, c;
debugVar("Begin:",{a,b,c},"end")

No no hay.
Además, si puede escribir variablesName(myFirstName), ya conoce el nombre de la variable ("myFirstName").