Nom de variable sous forme de chaîne en Javascript

Existe-t-il un moyen d'obtenir un nom de variable sous forme de chaîne en Javascript? (comme NSStringFromSelectordans Cocoa )

Je voudrais faire comme ceci:

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

--> myFirstName:John

METTRE À JOUR

J'essaye de connecter un navigateur et un autre programme en utilisant JavaScript. Je voudrais envoyer des noms d'instance d'un navigateur à un autre programme pour la méthode de rappel:

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

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

...

Depuis un autre programme:

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

En PHP: Comment obtenir un nom de variable sous forme de chaîne en PHP?

En règle générale, vous utilisez une table de hachage pour une situation dans laquelle vous souhaitez mapper un nom sur une valeur et être en mesure de récupérer les deux.

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

Comme la réponse de Seth, mais utilise à la Object.keys()place:

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

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

Vous pouvez utiliser la solution suivante pour résoudre votre problème:

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

// returns "myFirstName"

Dans ES6, vous pouvez écrire quelque chose comme:

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

Pas vraiment la plus belle chose, mais elle fait le travail.

Cela exploite la déstructuration des objets d'ES6.

Plus d'informations ici: https://hacks.mozilla.org/2015/05/es6-in-depth-destructuring/

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

Cependant, je pense que vous devriez faire comme "karim79"

Cela fonctionne pour les expressions de base

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

Exemple

nameof(() => options.displaySize);

Fragment:

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

Pop serait probablement mieux que l'indexation avec [0], pour des raisons de sécurité (la variable peut être nulle).

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

Cela ne peut pas être transformé en fonction car il renvoie le nom de la variable de la fonction.

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

Edit: Merci à @Madeo pour avoir indiqué comment en faire une fonction .

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

Vous devrez appeler la fonction avec un seul tableau d'éléments contenant la variable. debugVar({somefancyvariable});
Edit: Object.keyspeut être référencé comme keysdans tous les navigateurs dans lesquels je l'ai testé, mais selon les commentaires, cela ne fonctionne pas partout.

Depuis ECMAScript 5.1, vous pouvez utiliser Object.keys pour obtenir les noms de toutes les propriétés d'un objet.

Voici un exemple:

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

Lorsqu'une fonction écrit une fonction qui change les valeurs de différentes variables globales, ce n'est pas toujours mon prénom, c'est tout ce qui passe. Essayez cela a fonctionné pour moi.

_{Exécuter dans 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));

Ecrira dans la fenêtre «jack».

Vous pouvez réfléchir sur les types en javascript et obtenir le nom des propriétés et des méthodes, mais ce dont vous avez besoin, c'est qc comme Lambda Expressions Treesdans .NET, je pense que ce n'est pas possible en raison de la nature dynamique et du manque de système de type statique en javascript.

J'en avais besoin, je ne voulais pas utiliser d'objets et j'ai trouvé la solution suivante, renversant la question.

Au lieu de convertir le nom de la variable en une chaîne, je convertis une chaîne en une variable.

Cela ne fonctionne que si le nom de la variable est bien entendu connu.

Prends ça:

var height = 120;
testAlert(height);

Cela devrait afficher:

height: 120

Cela peut être fait comme ceci:

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

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

J'utilise donc la chaîne "height"et la transforme en variable heightà l'aide de la window[]commande.

Court moyen que j'ai trouvé jusqu'à présent pour obtenir le nom des variables sous forme de chaîne:

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

const whatsMyName = "Snoop Doggy Dogg";

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

Cela a fonctionné avec Internet Explorer (9, 10 et 11), Google Chrome 5:

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

Tableau de compatibilité du navigateur:
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys

J'ai créé cette fonction basée sur JSON comme quelqu'un l'a suggéré, fonctionne bien pour mes besoins de débogage

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

Non, il n'y en a pas.
De plus, si vous savez écrire variablesName(myFirstName), vous connaissez déjà le nom de la variable ("myFirstName").