-1

Just wondering if garbage collector takes care of an array returned by function. Will this function cause memory leaks if called many times?

1.    myFun = () => {
2.       let data = []
3.       for (let i=1; i<5; i++){
4.           data.push(id: i, name: 'temp')
5.       }
6.       return data
7.    }
8.    
9.    let myData1 = myFun()
10.   let myData2 = myFun()
11.   let myData3 = myFun()

so it creates three new arrays. But what the one defined in row #2?

John Glabb
  • 1,336
  • 5
  • 22
  • 52
  • There's nothing to garbage collect here. All three created arrays are assigned to actively scoped variables (`myData*`) – Phil Feb 08 '22 at 03:20

1 Answers1

0

But what the one defined in row #2?

That is the same exact array that is being returned. You aren't creating six arrays total (three inside, three outside) - you're creating three arrays total (three inside, which then get returned to the outside).

So, that array will remain un-garbage-collected as long as the returned expression remains referenceable. If your myData1, myData2, myData3 remain referenceable forever, none of the arrays will ever be garbage collected. If they become unreferenceable and nothing can continue using them, then they'll get garbage collected - for example, if you did

(() => {
    myFun = () => {
        let data = []
        for (let i = 1; i < 5; i++) {
            data.push(id: i, name: 'temp')
        }
        return data
    }

    let myData1 = myFun()
    let myData2 = myFun()
    let myData3 = myFun()
})();

Since myData1 etc aren't used again, and since the scope they're declared in ends, all arrays would then be shortly garbage collected.

CertainPerformance
  • 356,069
  • 52
  • 309
  • 320
  • what if I do let myData1 = myFun() three times, i.e. call meData1 to assign same data/array? So my question - will it cause memory leaks I'm calling let data =[] – John Glabb Feb 08 '22 at 03:24
  • The first two calls will result in arrays that cannot be referenced again, so those two arrays will be garbage collected. The third call will result in an array that can continue to be referenced, so it won't be garbage collected (at least until the scope ends or the identifier is reassigned again) – CertainPerformance Feb 08 '22 at 03:25