Variablenname als Zeichenfolge in Javascript

Gibt es eine Möglichkeit, einen Variablennamen als Zeichenfolge in Javascript abzurufen? (mögenNSStringFromSelector in Kakao )

Ich würde gerne so machen:

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

--> myFirstName:John

AKTUALISIEREN

Ich versuche, einen Browser und ein anderes Programm mit JavaScript zu verbinden. Ich möchte Instanznamen von einem Browser an ein anderes Programm zur Rückrufmethode senden:

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

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

...

Aus einem anderen Programm:

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

In PHP: Wie erhalte ich einen Variablennamen als String in PHP?

In der Regel verwenden Sie eine Hash-Tabelle für Situationen, in denen Sie einen Namen einem bestimmten Wert zuordnen und beide abrufen möchten.

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

Wie Seths Antwort, verwendet aber Object.keys()stattdessen:

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

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

Sie können die folgende Lösung verwenden, um Ihr Problem zu lösen:

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

// returns "myFirstName"

In ES6 können Sie Folgendes schreiben:

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

Nicht wirklich das am besten aussehende Ding, aber es erledigt den Job.

Dies nutzt die Objektzerstörung von ES6.

Weitere Informationen hier: https://hacks.mozilla.org/2015/05/es6-in-depth-destructuring/

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

Ich denke jedoch, Sie sollten "karim79" mögen

Dies funktioniert für grundlegende Ausdrücke

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

Beispiel

nameof(() => options.displaySize);

Snippet:

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

Wahrscheinlich wäre Pop aus Sicherheitsgründen besser als die Indizierung mit [0] (Variable könnte null sein).

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

Dies kann nicht zu einer Funktion gemacht werden, da der Name der Funktionsvariablen zurückgegeben wird.

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

Bearbeiten: Vielen Dank an @Madeo für den Hinweis, wie man daraus eine Funktion macht .

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

Sie müssen die Funktion mit einem einzelnen Elementarray aufrufen, das die Variable enthält. debugVar({somefancyvariable});
Bearbeiten: Object.keyskann als einfach bezeichnet werdenkeys in jedem Browser, in dem ich es getestet habe aber laut den Kommentaren funktioniert es nicht überall.

Seit ECMAScript 5.1 können Sie verwenden Object.keys verwenden , um die Namen aller Eigenschaften eines Objekts .

Hier ist ein Beispiel:

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

Wenn eine Funktion eine Funktion schreibt, die verschiedene globale Variablenwerte ändert, ist dies nicht immer mein Vorname, sondern das, was gerade passiert. Versuchen Sie, dass dies für mich funktioniert hat.

_{Laufen Sie in 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));

Schreibt in das Fenster 'Jack'.

Sie können über Typen in Javascript nachdenken und den Namen der Eigenschaften und Methoden abrufen. Was Sie jedoch benötigen, ist etwas wie Lambda Expressions Treesin .NET. Ich denke, dies ist aufgrund der Dynamik und des Fehlens eines statischen Typsystems in Javascript nicht möglich.

Ich brauchte das, wollte keine Objekte verwenden und fand die folgende Lösung, um die Frage umzudrehen.

Anstatt den Variablennamen in eine Zeichenfolge umzuwandeln, konvertiere ich eine Zeichenfolge in eine Variable.

Dies funktioniert natürlich nur, wenn der Variablenname bekannt ist.

Nimm das:

var height = 120;
testAlert(height);

Dies sollte Folgendes anzeigen:

height: 120

Dies kann folgendermaßen geschehen:

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

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

Also benutze ich den String "height"und verwandle ihn heightmit dem window[]Befehl in eine Variable .

Kurzer Weg, den ich bisher gefunden habe, um den Variablennamen als String zu erhalten:

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

const whatsMyName = "Snoop Doggy Dogg";

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

Dies funktionierte mit Internet Explorer (9, 10 und 11), Google Chrome 5:

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

Browserkompatibilitätstabelle:
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys

Ich habe diese Funktion basierend auf JSON erstellt, wie von jemandem vorgeschlagen, und funktioniert gut für meine Debug-Anforderungen

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

Nein, da ist kein.
Wenn Sie schreiben können variablesName(myFirstName), kennen Sie außerdem bereits den Variablennamen ("myFirstName").