JavaScript has many useful features that most developers know about. At the same time, there are some hidden gems that can solve really challenging problems if you're aware of them.
Metaprogramming in JavaScript is one such concept that many of us may not be familiar with. In this article, we will learn about Metaprogramming and how it's useful to us.
With ES6 (ECMAScript 2015), we have support for the Reflect and Proxy objects that allow us to do Metaprogramming with ease.
What is Metaprogramming?
Metaprogramming is nothing less than the magic in programming! How about writing a program that reads, modifies, analyzes, and even generates a program? Doesn't that sound wizardly and powerful?
Wikipedia describes Metaprogramming like this:
Metaprogramming is a programming technique in which computer programs have the ability to treat other programs as their data. This means that a program can be designed to read, generate, analyze, or transform other programs, and even modify itself while running.
Simply put, Metaprogramming involves writing code that can:
What is Reflection in Metaprogramming?
Reflection is a branch of Metaprogramming. Reflection has three sub-branches:
ES6 gives us the Reflect object (aka the Reflect API) to achieve Introspection. The Proxy object of ES6 helps us with Intercession. We won't talk too much about Self-Modification as we want to stay away from it as much as possible.
Hang on a second! Just to be clear, Metaprogramming wasn't introduced in ES6. Rather, it has been available in the language from its inception. ES6 just made it a lot easier to use.
Pre-ES6 era of Metaprogramming
Do you remember eval? Let's have a look at how it was used:
const blog = {
name: 'freeCodeCamp'
}
console.log('Before eval:', blog); // Before eval: {name: 'freeCodeCamp'}
const key = 'author';
const value = 'Alishoff';
testEval = () => eval(`blog.${key} = '${value}'`);
testEval();
console.log('After eval magic:', blog); // After eval magic: {name: 'freeCodeCamp', author: 'Alishoff'}
As you may notice, eval helped with additional code generation. In this case, the object blog has been modified with an additional property at execution time.
Introspection
Before the inclusion of the Reflect object in ES6, we could still do introspection. Here is an example of reading the structure of the program:
let users = {
'Tom': 32,
'Bill': 50,
'Sam': 65
};
Object.keys(users).forEach(name => {
const age = users[name];
console.log(`User ${name} is ${age} years old!`);
});
/*
User Tom is 32 years old!
User Bill is 50 years old!
User Sam is 65 years old!
*/
Here we are reading the users object structure and logging the key-value in a sentence.
Self Modification
Let's take a blog object that has a method to modify itself:
let blog = {
name: 'freeCodeCamp',
modifySelf: function(key, value) {
blog[key] = value;
}
}
blog.modifySelf('author', 'Alishoff');
console.log(blog.author); // Alishoff
Intercession
Intercession in metaprogramming means acting or changing things on behalf of somebody or something else. The pre-ES6 Object.defineProperty() method can change an object's semantics:
let sun = {};
Object.defineProperty(sun, 'rises', {
value: true,
configurable: false,
writable: false,
enumerable: false
});
console.log('sun rises', sun.rises); // sun rises true
sun.rises = false;
console.log('sun rises', sun.rises); // sun rises true
As you can see, the sun object was created as a normal object. Then the semantics were been changed so that it is not writable.
Now let's jump into understanding the Reflect and Proxy objects with their respective usages.
The Reflect API
In ES6, Reflect is a new Global Object (like Math) that provides a number of utility functions. Some of these functions may do exactly the same thing as the methods from Object or Function.
All these functions are Introspection functions where you could query some internal details about the program at the run time.
Here is the list of available methods from the Reflect object.
// Reflect object methods Reflect.apply() Reflect.construct() Reflect.get() Reflect.has() Reflect.ownKeys() Reflect.set() Reflect.setPrototypeOf() Reflect.defineProperty() Reflect.deleteProperty() Reflect.getOwnPropertyDescriptor() Reflect.getPrototypeOf() Reflect.isExtensible()
But wait, here's a question: Why do we need a new API object when these could just exist already or could be added to Object or Function?
Confused? Let's try to figure this out.
All in one namespace
JavaScript already had support for object reflection. But these APIs were not organized under one namespace. Since ES6 they're now under Reflect.
All the methods of the Reflect object are static in nature. It means, you do not have to instantiate the Reflect object using the new keyword.
Simple to use
The introspection methods of Object throw an exception when they fail to complete the operation. This is an added burden to the consumer (programmer) to handle that exception in the code.
You may prefer to handle it as a boolean(true | false) instead of using exception handling. The Reflect object helps you do that.
Here's an example with Object.defineProperty:
try {
Object.defineProperty(obj, name, desc);
} catch (e) {
// Handle the exception
}
And with the Reflect API:
if (Reflect.defineProperty(obj, name, desc)) {
// success
} else {
// failure (and far better)
}
The Proxy Object
ES6's Proxy object helps in intercession.
As the name suggests, a proxy object helps in acting on the behalf of something. It does this by virtualizing another object. Object virtualization provides custom behaviors to that object.
For example, using the proxy object we can virtualize object property lookup, function invocation, and so on. We will see some of these in detail more detail below.
Here are a few useful terms you need to remember and use:
A handler with a trap function should be defined. Then we need to create a Proxy object using the handler and the target object. The Proxy object will have all the changes with the custom behaviors applied.
It is perfectly fine if you don't quite understand yet from the description above. We will get a grasp of it through code and examples in a minute.
The syntax to create a Proxy object is as follows:
let proxy = new Proxy(target, handler);
There are many proxy traps (handler functions) available to access and customize a target object. Here is the list of them.
handler.apply() handler.construct() handler.get() handler.has() handler.ownKeys() handler.set() handler.setPrototypeOf() handler.getPrototypeOf() handler.defineProperty() handler.deleteProperty() handler.getOwnPropertyDescriptor() handler.preventExtensions() handler.isExtensible()
Note that each of the traps has a mapping with the Reflect object's methods. This means that you can use Reflect and Proxy together in many use cases.
How to get unavailable object property values
Let's look at an example of an employee object and try to print some of its properties:
const employee = {
firstName: 'Orkhan',
lastName: 'Alishov'
};
console.log(employee.firstName); // Orkhan
console.log(employee.lastName); // Alishov
console.log(employee.org); // undefined
console.log(employee.fullName); // undefined
Now let's use the Proxy object to add some custom behavior to the employee object.
const employee = {
firstName: 'Orkhan',
lastName: 'Alishov'
};
let handler = {
get: function(target, fieldName) {
if (fieldName === 'fullName' ) {
return `${target.firstName} ${target.lastName}`;
}
return fieldName in target ?
target[fieldName] :
`No such property as, '${fieldName}'!`
}
};
let proxy = new Proxy(employee, handler);
console.log(proxy.firstName); // Orkhan
console.log(proxy.lastName); // Alishov
console.log(proxy.org); // No such property as, 'org'!
console.log(proxy.fullName); // Orkhan Alishov
Notice how we have magically changed things for the employee object!
Proxy for Validation of Values
Let's create a proxy object to validate an integer value.
const employee = {
firstName: 'Orkhan',
lastName: 'Alishov'
};
const validator = {
set: function(obj, prop, value) {
if (prop === 'age') {
if (! Number.isInteger(value)) {
throw new TypeError('Age is always an Integer, Please Correct it!');
}
if (value < 0) {
throw new TypeError('This is insane, a negative age?');
}
}
}
};
let proxy = new Proxy(employee, validator);
proxy.age = 'I am testing a blunder'; // Uncaught TypeError: Age is always an Integer, Please Correct it!
How to use Proxy and Reflect together
Here is an example of a handler where we use methods from the Reflect API:
const employee = {
firstName: 'Orkhan',
lastName: 'Alishov'
};
let logHandler = {
get: function(target, fieldName) {
console.log("Log: ", target[fieldName]);
// Use the get method of the Reflect object
return Reflect.get(target, fieldName);
}
};
let func = () => {
let p = new Proxy(employee, logHandler);
p.firstName;
p.lastName;
};
func();
/*
Log: Orkhan
Log: Alishov
*/
In Summary
To summarize,