perdite di memoria Node.js?

Question

Ho un codice qui sotto che sto usando nell'app Express.js per centralizzare alcune logiche ACL. Se la funzione restituisce true o false in modo esplicito, il middleware può gestire la chiamata next. Ma se non ritorna, è compito della logica autorizza l'esecuzione di next() ogni volta che si finisce di fare la cosa.

Per evitare di dover scrivere i dati di errore, voglio solo passare una funzione error() che può essere chiamata, che chiama solo la funzione next internamente.

Qualcuno mi ha detto che questo può portare a qualche tipo di perdita di memoria poiché la funzione next si trova nella propria chiusura e fa riferimento dall'esterno. Vedo tecniche simili utilizzate in molti esempi online, ma sono ancora abbastanza nuovo su Node.js, quindi mi chiedo se c'è qualcosa di vero in questo?

this.router.use(function (req, res, next) { 
    var err = { 
      code: 403, 
      exception: 'UnauthorizedException', 
      data: {} 
     }, 
     error = function() { 
      next(err); 
     }, 
     authorize = app.route.authorize(req, res, next, error); 

    if (authorize === false) { 
     next(err); 
    } 
    else if (authorize === true) { 
     next(); 
    } 
}); 

EDIT: rimuovere le variabili

this.router.use(function (req, res, next) { 
    var authorize = app.route.authorize(req, res, next, function() { 
     next({ 
      code: 403, 
      exception: 'UnauthorizedException', 
      data: {} 
     }); 
    }); 

    if (authorize === false) { 
     next({ 
      code: 403, 
      exception: 'UnauthorizedException', 
      data: {} 
     }); 
    } 
    else if (authorize === true) { 
     next(); 
    } 
}); 

Answer 1

Quando si imposta il middleware, il metodo .use() viene chiamato una volta, l'anonimo gestore/middleware è scritto in memoria una volta, ed è lo stesso funzione middleware che viene chiamata per ogni nuova richiesta.

La variabile err viene creata un'istanza ogni volta che viene eseguito il middleware ed è un oggetto diverso. Se l'avessi messo all'esterno e nel raggio di chiusura di .use(), sarebbe lo stesso oggetto.

Viene quindi passato a next e next e molto probabilmente un'altra funzione di middleware che viene istanziata una volta e rimane la stessa in memoria che persiste e si impiglia nel suo accesso di chiusura.

Ma poi, quando la funzione next termina in esecuzione, l'oggetto a cui fa riferimento err perderà i suoi riferimenti - deve essere raccolto automaticamente.