How long is the data allocated to functions?

Question

In one language, (I don’t know if there’s any difference in others, but you can consider Javascript) when I have this situation:

function a() {
    b();
}

function b() {
    c();
}

function c() {
    d();
}

function d() {
    e();
}

function e() {
    f();
}

function f() {

}

What happens to things that are being created within methods? As it goes running it will release the memory or it keeps up the method F execute?

Answer 1

First nothing is running within these functions. There is no memory allocation, therefore there is nothing to be released.

If the example had some variable being allocated, at the end of the execution of each function, the content is released. Not the memory space occupied, since the memory is pre-allocated. Local function variables are placed in the pile (stack). Then each function call goes up the stack, and at the end goes back to the original position.

Then whatever is allocated in a, b, c, d, e will be kept there while these functions are running, they have only temporarily delegated to another function. As each one of them ends up releasing. The name stack is precisely to identify this well. You can’t release what’s underneath, to get something out of the pile that’s not on top just by taking out what’s above.

The stack exists whether to use it or not (it is impossible not to use it on anything that does anything at all useful). The space allocated to the stack is fixed, using or not. If it exceeds stack space occurs the famous stack overflow.

In general all languages work like this.

If there is any allocation on heap (see link above) this will not be released. The memory release strategy of the heap varies from language to language. Some require the programmer to do this, some do it more or less automatically, others do it perfectly, and still others do it to some extent. In general goes on the heap what is too big for the stack or that needs to survive at the end of the function.