In languages such as C++, being able to detect when an object goes out of scope is extremely useful in a wide range of use-cases (e.g., smart pointers, file access, mutexes, profiling). And I'm not talking about memory management vs. garbage collection here, as that is a different topic.
Consider a simple C++ example like this
class Profiler {
uint64 m_startTime;
Profiler::Profiler() :
m_startTime(someTimeFunction()) {
}
Profiler::~Profiler() {
const uint64 diff = someTimeFunction() - m_time;
printf("%llu ms have passed\n", diff);
}
}
We could do something like this
{
Profiler p; // creation of Profiler object on the stack
// Do some calculations
} // <- p goes out of scope and you will get the output message reporting the number of ms that have been passed
This clean example demonstrates the power of scoping. As a programmer I don't need to worry about manually calling methods; the rule is simple: the destructor is called once the object goes out of scope and I can make use of that.
In Javascript however there is no way, that I'm aware of at least, of mimicking this behavior. In the old days when let and const were not part of the language, this would've been less useful and even dangerous as one would never really know when a var went out of scope.
But when block scoping was added, I expected the programmer to get a bit of control over when an object goes out of scope. For instance a special method (like contructor()) that is called when it goes out of scope. But AFAIK this hasn't been done. Is there any reason as to why this isn't added?
Now we manually have to call a function, which defeats the whole purpose of block scoping for said use-case.
This would be the Javascript equivalent of the above C++ code:
class Profiler {
constructor() {
this.m_time = new Date().getTime();
}
report() {
const diff = new Date().getTime() - this.m_time;
console.log(`${diff} ms have passed`);
}
}
And the use-case would be this
{
const p = new Profiler;
// Do some calculations
p.report();
}
Which obviously is a lot less ideal. Because if I'm not careful in placing that p.report(); at the end of the block, the reporting is incorrect.
If there is a way to still do this, please let me know.
[EDIT]
The closest thing I came up with is this 'hackery'. I used async, but obviously that can be left out if all code in the block is synchronous.
// My profiler class
class Profiler {
constructor() {
this.m_time = new Date().getTime();
}
// unscope() is called when the instance 'goes out of scope'
unscope() {
const diff = new Date().getTime() - this.m_time;
console.log(`took ${diff} ms`);
}
};
async function Scope(p_instance, p_func) {
await p_func();
p_instance.unscope();
};
await Scope(new Profiler(), async () =>
{
console.log("start scope")
await sleep(100);
await Scope(new Profiler(), async () =>
{
await sleep(400);
});
await sleep(3000);
console.log("end scope")
});
console.log("after scope")
which resulted in
start scope
took 401 ms
end scope
took 3504 ms
after scope
Which is what I expected. But again
await Scope(new Profiler(), async () =>
{
});
is far less intuitive than simply
{
const p = new Profiler();
}
But at least I'm able to do what I want. If anyone else has a better solution, please let me know.
A destructor would be one way to achieve it but sadly Javascript doesn't support it. The reason you automatically get profile report after it goes out of scope is probably because it's destructor is called in C++. As of now there is no destructor in Javascript. Doing it manuelly as you showed would be the easiest way to achieve the C++ wanted behavior.
Different languages bring different syntax and capabilities to do stuff. Sometimes you need to adapt to the differences. C++ code is less prone to error in your case but I do not think there is an easy way to achieve the wanted behavior