Variable name as a string in JavaScript

Unwrapping JavaScript box of tricks

Dynamic variable name referencing

Do you need to petition a browser to send instance names to a server-side program? Are you developing callback methods? This slice of code may be your saving grace. The listening program can call precise methods linked to your instances:

// A function that could be the life of any JavaScript party
function callMethodOnInstance(instanceName, methodName) {
  // Assume 'instances' object is your being's host
  if (methodName in instances[instanceName]) {
    // Who said that JavaScript can't be an opera singer?
    return instances[instanceName][methodName]();
  }
  // A heroic error save, like a JavaScript superman
  throw new Error(`Method ${methodName} not found on instance ${instanceName}`);
}

let instanceName = Object.keys({myVar})[0];
callMethodOnInstance(instanceName, 'desiredMethod');


Scrumptious — dynamic referencing has never been so tasty!

Hash tables, variable mapping's finest

Magic hash tables and the preceding snippet form an alliance. In this legendary union, name-to-value mapping is made efficient. This resembles the symbolic referencing in PHP:

let hashTable = {
  'instanceOne': instanceOne,
  'instanceTwo': instanceTwo
};

let varName = Object.keys({instanceOne})[0];
let instance = hashTable[varName];

// Abracadabra! You can now perform actions on 'instance'


Capitalizing on ES6 syntax: cleaner, leaner code

ES6's destructuring empowers you to extract numerous variable names as strings. The result? A cleaner, expressively wealthy language:

let [a, b, c] = [1, 2, 3];
let varNames = {a, b, c};
let namesAsStrings = Object.keys(varNames);

console.log(namesAsStrings); // ["a", "b", "c"]
// It's like a JavaScript choir singing harmoniously!


Create a nameOf function - your code's hero

Boost your reusability standards by encasing this behaviour in a nameOf function. Grabbing variable names dynamically has never been so straighforward:

function nameOf(variable) {
  return Object.keys({variable})[0];
}

let myVarName = nameOf(myVar); // Returns: "myVar"
// Hey presto! JavaScript magic!


Callbacks and class instances: opportunities aplenty

When dealing with class instances or callbacks, the advantage is clear. Convert variable instances into their names for dynamic reference and access new dimensions:

class MyClass {
  constructor(name) {
    this.name = name;
  }

  sayHello() {
    // Who knew that JavaScript classes had manners?
    console.log(`Hello from ${this.name}!`);
  }
}

let instance = new MyClass('instanceOne');
let instanceName = Object.keys({instance})[0];

console.log(instanceName); // "instance"
instance.sayHello(); // "Hello from instanceOne!"
// JavaScript's personality shines!


For...in loops exploring properties

When complexity unfolds, use for...in loops to lay object properties bare as strings. Continue operating on values while traversing string names:

let complexObject = {
  propOne: 'valueOne',
  propTwo: 'valueTwo'
};

for (let propName in complexObject) {
  console.log(propName); // Prints out: "propOne", "propTwo"
  // It's like JavaScript's take on Oprah: You get a name! And you get a name!
}


Beyond strings: variable essence exploration

Emulating language capabilities

In languages like PHP, variable name retrieval as string data is a commonplace. With the extraction of object literal keys, JavaScript dances a similar waltz:

$variableName = 'myVariable';
echo $$variableName; // Logs: 'myVariable'
// Sweet symphony of PHP & JavaScript!


JSON.stringify: object-to-string conversion

As per your needs, string conversion can comprise both a variable's name and content through use of JSON.stringify().

let obj = { a: 1, b: 2 };
let nameAndValue = JSON.stringify(obj, null, 2);
console.log(nameAndValue);
/*
{
  "a": 1,
  "b": 2
}
*/
// It's like JavaScript's version of a reality show reveal!


Higher-order function value in dynamic variable handling

With higher-order functions, we unlock advanced abstraction levels. These in turn allow for powerful manipulations regarding variable names as strings and offer dynamic access and operational potential on variables:

function manipulateVar(variable, operation) {
  let varName = Object.keys({variable})[0];
  return operation(varName);
}

let result = manipulateVar(myVar, (name) => `Manipulated value of ${name}`);
console.log(result); // Prints out: "Manipulated value of myVar"
// Remember! With JavaScript, flexibility is the key!
