Metaprogramming is a programming technique (or approach) which involves treating programs as data, enabling them to be read, generated, analysed, transformed, and even modified dynamically. It empowers developers to interact with and manipulate other programs programmatically.

Essentially, this concept conveys that metaprogramming enables us to create sophisticated programs with the ability to generate new programs or comprehend their own structure. However, what does this actually mean in practice?

To begin, it is essential to grasp that metaprogramming encompasses both language capabilities and approaches to writing logic in a metaprogramming style.

I would like to start my explanation with the aspect that emphasises metaprogramming as the program's self-awareness and the ability to manipulate itself at runtime.

Reflection stands out as a significant tool in this context. It's the concept within metaprogramming, which draws parallels to seeing our own reflection in a mirror. In a similar manner, reflection allows us to gain insights into aspects of a program that would otherwise remain hidden. It provides the capability to introspect and access different elements of a program, such as properties, methods, and structure. This ability to observe and modify a program's internal workings facilitates advanced program analysis and dynamic adaptations.

At its core, reflection allows an object to introspect its own properties and methods, enabling self-examination and potential modification. In the case of JavaScript, this capability empowers objects to dynamically explore their own structure, accessing and manipulating properties and methods as required.

In JavaScript, the Reflect API serves as the implementation of Reflection. It is introduced as a set of static methods provided by the global Reflect object, which consists of a collection of related functions rather than properties. It provides static methods that allow for the invocation of interceptable internal methods of JavaScript objects. These functions, introduced in ES6, establish an API for introspecting and manipulating objects and their properties.

The Reflect object serves as a convenient namespace that encapsulates a set of functions replicating the behaviour of core language syntax and duplicating the functionality of existing Object functions. While the Reflect functions themselves do not introduce new features, they consolidate these features into a unified and convenient API.

Example 1 - Accessing properties:

// Example object
const myObject = {
  name: 'John',
  age: 25
};

// Using Reflect to get a property value
const name = Reflect.get(myObject, 'name');

// Without using Reflect to get a property value
const name = myObject['name']; // or myObject.name 

console.log(name); // Output: "John"

Example 2 - Set properties:

const myObject = {
  name: 'John',
  age: 25
};

// Using Reflect.set() to update a property value
Reflect.set(myObject, 'age', 30);

// Without using Reflect to set a property value
myObject['age'] = 30; // or myObject.age = 30

// Result
console.log(myObject.age); // Output: 30

Example 3 - Invoke a target function with a specified this value and a set of arguments:

const obj = {
  name: 'John',
  greet() {
    console.log(`Hello, ${this.name}!`);
  }
};

const greetFunc = obj.greet;
const args = [];

// Using Reflect.apply() to invoke the greet method on the obj object
Reflect.apply(greetFunc, obj, args);

// Without using Reflect
greetFunc.apply(obj, args); 

// Output: "Hello, John!"

By the way, it's worth noting that mentioning Reflect.apply() during interviews when discussing binding context can be quite impressive. It showcases a deeper understanding of JavaScript's function invocation mechanisms, going beyond just mentioning call, apply, and bind.

Example 4 - Retrieve an array of all property keys, including both enumerable and non-enumerable:

const obj = {
  name: 'John',
  age: 25
}

Object.defineProperty(obj, 'address', {
  value: '123 Main St',
  enumerable: false
});

const symbolKey = Symbol('id');
Object.defineProperty(obj, symbolKey, {
  value: 123,
  enumerable: false
});

// Using Reflect.ownKeys()
const keys = Reflect.ownKeys(obj);

// Without Reflect
const keys = Object.getOwnPropertyNames(obj).concat(Object.getOwnPropertySymbols(obj));

// Result
console.log(keys); // Output: ['name', 'age', 'address', Symbol(id)]

It's important to note that Reflect is not intended to be used as a constructor. It cannot be invoked with the new operator or treated as a regular function. All properties and methods of the Reflect object are static, mirroring the behaviour of the Math object.

Example 5 - Let's also create our own implementation of the Reflect object to gain a better understanding of its functionality:

class Reflect {

  static get(target, propertyKey, receiver) {
    if (typeof target !== 'object' || target === null) {
      throw new TypeError('Reflect.get called on non-object');
    }
    return target[propertyKey];
  }

  static set(target, propertyKey, value, receiver) {
    if (typeof target !== 'object' || target === null) {
      throw new TypeError('Reflect.set called on non-object');
    }
    target[propertyKey] = value;
    return true;
  }

  static apply(target, thisArg, args) {
    if (typeof target !== 'function') {
      throw new TypeError('Reflect.apply called on non-function');
    }
    return target.apply(thisArg, args);
  }

  static ownKeys(target) {
    if (typeof target !== 'object' || target === null) {
      throw new TypeError('Reflect.ownKeys called on non-object');
    }
    return Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target));
  }

  // Additional Reflect methods can be implemented here
}

// Example usage:
const myObject = {
  name: "John",
  age: 25
};

console.log(Reflect.get(myObject, "name")); // Output: "John"
console.log(Reflect.set(myObject, "age", 30)); // Output: 30

So, Reflect API in JavaScript provides a powerful set of methods that enable metaprogramming capabilities. By leveraging reflection, developers can gain insight into program structures, dynamically modify behaviour, and achieve advanced program analysis. The Reflect API offers a convenient and unified approach to interact with objects, mimicking core language syntax and providing an efficient way to access and manipulate properties, invoke functions, and work with object metadata. By harnessing the capabilities of the Reflect API, developers can take their programming to the next level, empowering them to build more flexible, dynamic, and intelligent applications.

You can find the comprehensive list of available methods of the Reflect object here.