Блог

Пожалуйста, не стесняйтесь разобраться со мной, если это избыточный вопрос. (Я искал столько, сколько мог, прежде чем спрашивать)

Я отчаянно пытаюсь понять жизненный цикл объектов запроса / ответа.

Рассмотрим следующий скелетный код:

 app.get('/', function(req, res) {

  var setCookie = function(err, idCookie) { //callback after cookieSearch in DB
    // ... do something with the result of findCookieInDatabase() (handle error, etc.);
    res.sendfile('index.html');
  }

  var cookie = parseCookie(req.get('Cookie')); //parse and format cookie

  findCookieInDatabase(cookie, afterCookieSearch); //tries to find cookie is DB


  // .. do some content return stuff, etc.
}
  

(Пожалуйста, обратите внимание, что исходный код выполняет намного больше, например, проверяет, существует ли «Cookie» и т. Д.)

Я понимаю, что объекты req и res создаются и в какой-то момент должны быть собраны как мусор. (Можно было бы надеяться)

Когда findCookieInDatabase() вызывается с setCookie в качестве параметра, я предполагаю, что setCookie — это просто строка (содержащая функцию) в данный момент и не анализируется и не выполняется до тех пор, пока оператор обратного вызова (setCookie) не встретится в findCookieInDatabase() .

Я также понимаю, что я могу быть совершенно неправ в приведенном выше предположении, что было бы связано с моим непониманием сути обратных вызовов javascript. (Я также много искал по этому вопросу, но все, что я мог найти, — это бесконечные подсказки о том, как использовать обратные вызовы. Ничего о том, что находится под капотом)

Итак, вопрос заключается в следующем: Как javascript (или node.js ) знать, как долго поддерживать «res» в рабочем состоянии и когда можно собирать мусор?

Действительно ли строка res.sendfile в setCookie действует как активная ссылка, потому что она вызывается через findCookieInDatabase() ?

Действительно ли javascript отслеживает все ссылки и поддерживает req и / или res в рабочем состоянии до тех пор, пока какая-либо часть любого вызываемого / вызываемого обратного вызова / вещей жива?

Любая помощь с благодарностью. Спасибо за чтение.

Многое происходит с вашим кодом — и вашими предположениями — что указывает мне на то, что вам следует изучить некоторые основы JavaScript. Я бы порекомендовал следующие книги:

• Говорящий на JavaScript, Аксель Раушмайер
• JavaScript: хорошие части, Дуглас Крокфорд (пожалуйста, обратите внимание: я не думаю, что все, что говорит Дуглас Крокфорд, является золотым, но я бы счел эту книгу обязательной для чтения начинающим программистам JavaScript)
• Обучающий узел, автор Shelley Powers

И, конечно, моя собственная книга «Веб-разработка с использованием Node и Express«. Хорошо, теперь, когда я разобрался со всеми материалами для чтения, позвольте мне попытаться добраться до сути вашего вопроса.

Когда узел получает HTTP-запрос, он создает объекты req and res (которые начинают свою жизнь как экземпляры http.IncomingMessage and http.ServerResponse соответственно). Предполагаемое назначение этих объектов заключается в том, что они живут столько, сколько выполняет HTTP-запрос. То есть клиент выполняет HTTP-запрос, req res создаются объекты and , происходит куча вещей, и, наконец, вызывается метод on res , который отправляет HTTP-ответ обратно клиенту, и в этот момент объекты больше не нужны.

Из-за асинхронной природы узла req в любой момент времени может быть несколько res объектов and, отличающихся только областью, в которой они находятся. Это может показаться запутанным, но на практике вам никогда не придется беспокоиться об этом: когда вы пишете свой код, вы пишете его так, как если бы вы всегда имели дело с одним HTTP-запросом, а ваша платформа (например, Express) управляет несколькими запросами.

В JavaScript действительно есть сборщик мусора, который в конечном итоге освобождает объекты после того, как их количество ссылок падает до нуля. Таким образом, для любого данного запроса, пока есть ссылка на req объект (например), этот объект не будет освобожден. Вот простой пример экспресс-программы, которая всегда сохраняет каждый запрос (кстати, это ужасная идея):

 var allRequests = [];
app.use(function(req, res, next) {
    allRequests.push(req);
    next();
});
  

Причина, по которой это ужасная идея, заключается в том, что если вы никогда не удаляете объекты allRequests , вашему серверу в конечном итоге не хватит памяти при обработке трафика.

Как правило, с помощью Express вы будете полагаться на асинхронные функции, которые вызывают обратный вызов после выполнения своей работы. Если функция обратного вызова имеет ссылку на объекты req or res , они не будут освобождены до завершения асинхронной функции и выполнения обратного вызова (и все остальные ссылки, естественно, выходят за рамки). Вот простой пример, который просто генерирует искусственную задержку:

 app.get('/fast', function(req, res) {
    res.send('fast!');
});

app.get('/slow', function(req, res) {
    setTimeout(function() {
        res.send('sloooooow');
    }, 3000);
});
  

Если вы перейдете к /slow , ваш браузер будет вращаться в течение 3 секунд. В другом браузере, если вы обращаетесь /fast к куче раз, вы обнаружите, что он все еще работает. Это потому, что Express создает req res объект and для каждого запроса, ни один из которых не мешает друг другу. Но res объект, связанный с /slow запросом, не освобождается, потому что обратный вызов (который содержит ссылку на этот экземпляр) не выполнен.

В конце концов, я чувствую, что вы слишком много думаете. Конечно, полезно понимать основы, но по большей части подсчет ссылок и сборка мусора в JavaScript — это не то, о чем вам нужно думать или управлять.

Надеюсь, это поможет.