Wpadłem na ten błąd, jak również na chwilę. Myślę (mam nadzieję), że owinąłem głowę wokół tego, chciałem napisać to tutaj w celach informacyjnych.

Kiedy dodajesz middleware do connect lub express (który jest zbudowany na connect) przy użyciu metody app.use, dodajesz elementy do Server.prototype.stack w connect (przynajmniej z bieżącym npm install connect, który wygląda zupełnie inaczej niż ten github z tego postu). Gdy serwer otrzyma żądanie, iterację nad stosem, wywołując (request, response, next) metoda.

Problem polega na tym, że jeśli w jednym z elementów middleware zapisuje się do ciała odpowiedzi lub nagłówków (wygląda na to, że jest albo/lub z jakiegoś powodu), ale nie wywołuje response.end() i wywołujesz next() następnie, gdy metoda core Server.prototype.handle zakończy się, zauważy, że:

1. nie ma więcej przedmiotów w stosie, i / lub
To prawda.

Więc wyrzuca błąd. Ale błąd jaki rzuca to tylko ta podstawowa odpowiedź (z connect http.js kod źródłowy:

res.statusCode = 404;
res.setHeader('Content-Type', 'text/plain');
res.end('Cannot ' + req.method + ' ' + req.url);

Tutaj, to wywołanie res.setHeader('Content-Type', 'text/plain'); , które prawdopodobnie ustawiłeś w swojej metodzie render, bez wywołania odpowiedzi.end () , coś w stylu:

response.setHeader("Content-Type", "text/html");
response.write("<p>Hello World</p>");

Sposób, w jaki wszystko musi być zorganizowane jest tak:

Dobra Middleware

// middleware that does not modify the response body
var doesNotModifyBody = function(request, response, next) {
  request.params = {
    a: "b"
  };
  // calls next because it hasn't modified the header
  next();
};

// middleware that modify the response body
var doesModifyBody = function(request, response, next) {
  response.setHeader("Content-Type", "text/html");
  response.write("<p>Hello World</p>");
  response.end();
  // doesn't call next()
};

app.use(doesNotModifyBody);
app.use(doesModifyBody);

Problematyczne Oprogramowanie Pośrednie

var problemMiddleware = function(request, response, next) {
  response.setHeader("Content-Type", "text/html");
  response.write("<p>Hello World</p>");
  next();
};

Problematyczne oprogramowanie pośredniczące ustawia nagłówek odpowiedzi bez wywoływania response.end() i wywoływania next(), co myli serwer connect.

_{niektóre odpowiedzi w tym Q&A są błędne. Przyjęta odpowiedź również nie jest zbyt "praktyczna", więc chcę opublikować odpowiedź, która wyjaśni rzeczy w prostszy sposób. Moja odpowiedź obejmie 99% błędów, które widzę publikowane w kółko. Dla rzeczywistych przyczyn błędu spójrz na zaakceptowaną odpowiedź.}

HTTP używa cyklu, który wymaga jednej odpowiedzi na każde żądanie. Gdy klient wysyła żądanie (np. POST lub GET) serwer powinien wysłać tylko jedna odpowiedź.

Ten Komunikat o błędzie:

Błąd: nie można ustawić nagłówków po ich wysłaniu.

Zwykle zdarza się, gdy wyślesz kilka odpowiedzi na jedno żądanie. Upewnij się, że następujące funkcje są wywoływane tylko raz na żądanie:

• res.json()
• res.send()
• res.redirect()
• res.render()

_{(i kilka innych, które są rzadko używane, sprawdź zaakceptowaną odpowiedź)}

Trasa nie powróci po wywołaniu tych funkcji res. Będzie ona nadal działać, dopóki nie trafi na koniec funkcji lub instrukcji return. Jeśli chcesz wrócić podczas wysyłania odpowiedzi, możesz to zrobić tak: return res.send().

Weźmy na przykład ten kod:

app.post('/api/route1', function(req, res) {
  console.log('this ran');
  res.status(200).json({ message: 'ok' });
  console.log('this ran too');
  res.status(200).json({ message: 'ok' });
}

Gdy żądanie POST zostanie wysłane do / api / route1, uruchomi każdą linię wywołania zwrotnego. nie można ustawić nagłówków po ich wysłaniu komunikat o błędzie zostanie wyrzucony, ponieważ res.json() jest wywoływany dwukrotnie, co oznacza wysłano dwie odpowiedzi.

Tylko jedna odpowiedź może być wysłana na żądanie!

Błąd w powyższym kodzie był oczywisty. Bardziej typowym problemem jest, gdy masz kilka gałęzi:

app.get('/api/company/:companyId', function(req, res) {
  const { companyId } = req.params;
  Company.findById(companyId).exec((err, company) => {
      if (err) {
        res.status(500).json(err);
      } else if (!company) {
        res.status(404).json();      // This runs.
      }
      res.status(200).json(company); // This runs as well.
    });
}

Ta trasa z załączonym callback znajduje firmę w bazie danych. Wykonując Zapytanie o firmę, która nie istnieje, dostaniemy się do oddziału else if i wyślemy odpowiedź 404. Następnie przejdziemy do następnego oświadczenia, które również wysyła odpowiedź. Teraz wysłaliśmy dwie odpowiedzi i pojawi się komunikat o błędzie. Możemy naprawić ten kod, upewniając się, że wysyłamy tylko jedną odpowiedź:

.exec((err, company) => {
  if (err) {
    res.status(500).json(err);
  } else if (!company) {
    res.status(404).json();         // Only this runs.
  } else {
    res.status(200).json(company);
  }
});

Lub zwracając po wysłaniu odpowiedzi:

.exec((err, company) => {
  if (err) {
    return res.status(500).json(err);
  } else if (!company) {
    return res.status(404).json();  // Only this runs.
  }
  return res.status(200).json(company);
});

Wielki grzesznik to funkcje asynchroniczne. Weźmy funkcję z tego pytania, na przykład:

article.save(function(err, doc1) {
  if (err) {
    res.send(err);
  } else {
    User.findOneAndUpdate({ _id: req.user._id }, { $push: { article: doc._id } })
    .exec(function(err, doc2) {
      if (err) res.send(err);
      else     res.json(doc2);  // Will be called second.
    })

    res.json(doc1);             // Will be called first.
  }
});

Tutaj Mamy funkcję asynchroniczną (findOneAndUpdate()) w próbce kodu. Jeśli nie ma błędów (err) findOneAndUpdate() zostanie wezwany. Ponieważ funkcja ta jest asynchroniczny res.json(doc1) zostanie wywołany natychmiast. Załóżmy, że w findOneAndUpdate() nie ma żadnych błędów. res.json(doc2) w else będą wtedy wywoływane. Wysłano dwie odpowiedzi i pojawia się komunikat o błędzie Can ' t set headers.

Poprawką w tym przypadku byłoby usunięcie res.json(doc1). Aby wysłać oba dokumenty z powrotem do klienta, res.json() w else można zapisać jako res.json({ article: doc1, user: doc2 }).

Miałem ten sam problem i zdałem sobie sprawę, że to dlatego, że wołałem res.redirect bez instrukcji return, więc funkcja next była wywoływana natychmiast po tym:

auth.annonymousOnly = function(req, res, next) {
    if (req.user) res.redirect('/');
    next();
};

Które powinno być:

auth.annonymousOnly = function(req, res, next) {
    if (req.user) return res.redirect('/');
    next();
};

Wiele osób uderzyło w ten błąd. Jest to mylące z przetwarzaniem asynchronicznym. Najprawdopodobniej część kodu ustawia nagłówki w pierwszym tyknięciu, a następnie uruchamiasz wywołanie zwrotne asynchroniczne w przyszłym tyknięciu. Pomiędzy nimi wysyłany jest nagłówek odpowiedzi, ale kolejne nagłówki (jak przekierowanie 30X) próbują dodać dodatkowe nagłówki, ale jest już za późno, ponieważ nagłówek odpowiedzi został już przesłany.

Nie wiem dokładnie co jest przyczyną twojego błędu, ale spójrz na wszelkie wywołania zwrotne jako potencjalne obszary do zbadania.

Jedna prosta wskazówka, aby uprościć kod. Pozbądź się app.configure() i po prostu zadzwoń app.use bezpośrednio do swojego zakresu najwyższego poziomu.

Zobacz także modułeveryauth , który obsługuje Facebook i kilkunastu innych dostawców uwierzytelniania stron trzecich.

Przegiąłem nad tym problemem i stało się to z powodu nieostrożnego błędu w obsłudze wywołań zwrotnych. nieodwracalne wywołania zwrotne powodują dwukrotne ustawienie odpowiedzi.!

Mój program miał kod, który waliduje żądanie i odpytywał DB. po sprawdzeniu, czy jest błąd, oddzwaniałem do indeksu.js z błędami walidacji . A jeśli Walidacja przejdzie, idzie do przodu i uderza w db z sukcesem/porażką.

    var error = validateRequestDetails("create",queryReq);
    if (error)
        callback(error, null);
   else
    some code 
    callback(null, success);

Co się działo to: Walidacja Incase nie powiodła się callback get called and response get set. Ale nie wrócił. Więc nadal trwa metoda idzie do db i hit sukces/porażka . Ponownie wywołuje to samo wywołanie zwrotne, powodując dwukrotne ustawienie odpowiedzi.

Więc rozwiązanie jest proste, musisz "zwrócić" wywołanie zwrotne, aby metoda nie kontynuowała wykonywania, po wystąpieniu błędu i tym samym ustawić obiekt odpowiedzi raz

  var error = validateRequestDetails("create",queryReq);
    if (error)
        callback(error, null);
        return;
    else
       some code 
       callback(null, success);

Ten typ błędu pojawi się podczas przekazywania instrukcji po wysłaniu odpowiedzi.

Na przykład:

res.send("something response");
console.log("jhgfjhgsdhgfsdf");
console.log("sdgsdfhdgfdhgsdf");
res.send("sopmething response");

Spowoduje wyświetlenie błędu, ponieważ po wysłaniu odpowiedzi następująca res.send nie zostanie wykonana.

Jeśli chcesz coś zrobić, powinieneś to zrobić przed wysłaniem odpowiedzi.

Czasami może wystąpić ten błąd podczas próby wywołania funkcji next() po res.end lub res.send , spróbuj usunąć, jeśli masz funkcję next () po res.send lub res.end. Uwaga: tutaj next() oznacza, że po udzieleniu odpowiedzi klientowi ( tj. res. send lub res. end ) nadal próbujesz wykonać jakiś kod, aby odpowiedzieć ponownie, więc nie jest to legalne.

Przykład:

router.get('/',function (req,res,next){
     res.send("request received");
     next(); // this will give you the above exception 
});

Usuń next() z powyższej funkcji i będzie praca.

Error find by self after a RND:

1) Mój kod błędu:

return res.sendStatus(200).json({ data: result });

2) Mój kod sukcesu

return res.status(200).json({ data: result });

Różnica polega na tym, że użyłem sendStatus()zamiast status().

Jeśli używasz funkcji callback użyj return po bloku err. Jest to jeden ze scenariuszy, w których ten błąd może się zdarzyć.

userModel.createUser(data, function(err, data) {
    if(err) {
      res.status = 422
      res.json(err)
      return // without this return the error can happen.
    }
    return res.json(data)
  })

Testowane Na wersji węzła v10.16.0 i express 4.16.4

Ten błąd występuje, gdy wysyłasz 2 odpowiedzi. Na przykład:

if(condition A)
{ 

      res.render('Profile', {client:client_});

}

if (condition B){

      res.render('Profile', {client:client_});
    }
  }

Wyobraź sobie, że z jakiegoś powodu Warunki a i B są prawdziwe, więc w drugim render dostaniesz ten błąd

Dla każdego, kto do tego dochodzi i żadne inne rozwiązania nie pomogły, w moim przypadku przejawiało się to na trasie, która obsługiwała przesyłanie obrazów, ale nie obsługiwała timeouts, w związku z tym, jeśli przesyłanie trwało zbyt długo i wygasło, kiedy wywołanie zwrotne zostało wywołane Po wysłaniu odpowiedzi timeout, wywołanie res.send() spowodowało awarię, ponieważ nagłówki były już ustawione na rozliczanie limitu czasu.

Można to łatwo odtworzyć, ustawiając bardzo krótki timeout i uderzając w trasę z przyzwoicie dużym obrazem, wypadek był odtwarzany za każdym razem.

W moim przypadku stało się to z React i postal.js, gdy nie wypisałem się z kanału w wywołaniu zwrotnym componentWillUnmount mojego komponentu Reactowego.

Po prostu dodaję słowo kluczowe return jak: return res.redirect("/great"); i walla!

W moim przypadku była to odpowiedź 304 (buforowanie), która powodowała problem.

Najprostsze rozwiązanie:

app.disable('etag');

Alternatywne rozwiązanie tutaj, jeśli chcesz mieć większą kontrolę:

Http://vlasenko.org/2011/10/12/expressconnect-static-set-last-modified-to-now-to-avoid-304-not-modified/

/ Align = "left" / Odpowiedzi można przekazać za pomocą tej funkcji:

app.use(function(req,res,next){
  var _send = res.send;
  var sent = false;
  res.send = function(data){
    if(sent) return;
    _send.bind(res)(data);
    sent = true;
};
  next();
});

Dodaj to middleware i będzie działać

app.use(function(req,res,next){
 var _send = res.send;
var sent = false;
res.send = function(data){
    if(sent) return;
    _send.bind(res)(data);
    sent = true;
};
next();
});

Dzieje się tak, gdy odpowiedź została dostarczona do klienta i ponownie próbujesz udzielić odpowiedzi. Musisz sprawdzić w swoim kodzie, że gdzieś zwracasz odpowiedź do Klienta ponownie, co powoduje ten błąd. Sprawdź i zwróć odpowiedź raz, gdy chcesz wrócić.

Jest coś jeszcze, co powoduje ten błąd i jest to, gdy nie dodajesz return słowa kluczowego przed res.send, res.json, itp...

Jest bardzo prawdopodobne, że jest to bardziej rzecz węzła, 99% czasu jest to podwójne wywołanie zwrotne powodujące, że odpowiadasz dwa razy, lub next()ING dwa razy itp, cholernie pewny. Moim problemem było użycie next () wewnątrz pętli. Usuń next () z pętli lub przestań ją wywoływać więcej niż jeden raz.

Miałem ten sam problem, który był spowodowany mangustą.

Aby to naprawić, musisz włączyć Promises, aby dodać : {[3] } do kodu, który umożliwia użycie native js promises.

Inne alternatywy dla tej soloution to:

var mongoose = require('mongoose');
// set Promise provider to bluebird
mongoose.Promise = require('bluebird');

I

// q
mongoose.Promise = require('q').Promise;

Ale najpierw musisz zainstalować te pakiety.

Miałem ten problem, gdy zagnieżdżałem obietnice. Obietnica wewnątrz obietnicy zwróci 200 na serwer, ale wtedy zewnętrzna obietnica zwróci 500. Kiedy to naprawiłem, problem zniknął.

W moim przypadku dzieje się to z powodu wielu wywołań zwrotnych. Wywołałem next() metodę wiele razy podczas kodu

Przyszedł tutaj z nuxt , problem tkwił w metodzie asyncData komponentu, zapomniałem return promise, która pobierała Dane i ustawiała tam nagłówek.

Otrzymałem podobny błąd, gdy próbowałem wysłać odpowiedź w ramach funkcji pętli. Prostym rozwiązaniem było przeniesienie

Res. send ('wyślij odpowiedź');

Z pętli, ponieważ możesz wysłać nagłówek odpowiedzi tylko raz.

Https://www.tutorialspoint.com/nodejs/nodejs_response_object.htm

Proszę sprawdzić, czy twój KOD Zwraca Wiele res.send() poleceń dla pojedynczego żądania. Jak wtedy, gdy miałem ten problem....

Byłem tym problemem w mojej aplikacji restify node. Błąd polegał na tym, że

switch (status) {
    case -1:
      res.send(400);
    case 0:
      res.send(200);
    default:
      res.send(500);
}

Zajmowałem się różnymi sprawami używając przełącznika bez przerwy na pisanie. Dla tych mało zaznajomionych z przypadku switch wiedzieć, że bez przerwy, powrót słów kluczowych. Kod pod wielkość liter i następne jego wiersze będą wykonywane bez względu na wszystko. Więc mimo, że chcę wysłać singiel res.send, ze względu na błąd ten polegał na zwracaniu wielu res.send wypowiedzi, które wywołały

Błąd: nie można ustawić nagłówków po wysłaniu ich do klienta.

Które zostały rozwiązane przez dodanie tego lub użycie return przed każdą res.send() metodą jak return res.send(200)

switch (status) {
    case -1:
      res.send(400);
      break;
    case 0:
      res.send(200);
      break;
    default:
      res.send(500);
      break;
}

W maszynopisie mój problem polegał na tym, że nie zamykałem połączenia websocket po otrzymaniu wiadomości.

WebSocket.on("message", (data) => {
    receivedMessage = true;
    doSomething(data);
    localSocket.close(); //This close the connection, allowing 
});

Jeśli nie otrzymacie pomocy z góry : dla noobów Powodem tego błędu jest wielokrotne wysyłanie żądania.:- 1. `

module.exports = (req,res,next)=>{
        try{
           const decoded  = jwt.verify(req.body.token,"secret");
           req.userData = decoded;
           next();
        }catch(error){
            return res.status(401).json({message:'Auth failed'});
        }
        next();   
        }

` w powyższym wywołaniu dwukrotnie next () spowoduje błąd

1. router.delete('/:orderId', (req, res, next) => { Order.remove({_id:req.params.orderId},(err,data)=>{ if(err){ **res.status(500).json(err);** }else{ res.status(200).json(data); } *res.status(200).json(data);* }) })

Tutaj odpowiedź jest wyślij dwa razy sprawdź czy Już wysłałeś odpowiedź

Mój problem polegał na tym, że miałem setInterval uruchomiony, który miał if/else blok, gdzie metoda clearInterval znajdowała się wewnątrz else:

      const dataExistsInterval = setInterval(async () => {
        const dataExists = Object.keys(req.body).length !== 0;
        if (dataExists) {
          if (!req.files.length) {
            return res.json({ msg: false });
          } else {
              clearInterval(dataExistsInterval);
            try {
            . . .

Umieszczenie clearInterval przed if/else załatwiło sprawę.

W moim przypadku, w pętli, umieścić res.render() więc może być próbował zadzwonić wiele razy.