Co to jest nieobsługiwane odrzucenie obietnicy?

Do nauki gry Angular 2 próbuję ich samouczka.

Otrzymuję taki błąd:

(node:4796) UnhandledPromiseRejectionWarning: Unhandled promise rejection (r                                                                                                     ejection id: 1): Error: spawn cmd ENOENT
[1] (node:4796) DeprecationWarning: Unhandled promise rejections are deprecated.
In the future, promise rejections that are not handled will terminate the Node.
js process with a non-zero exit code.

Przeanalizowałem różne pytania i odpowiedzi w SO, ale nie mogłem dowiedzieć się, co to jest „nieobsługiwane odrzucenie obietnicy”.

Czy ktoś może mi po prostu wyjaśnić, co to jest, a także co Error: spawn cmd ENOENT, kiedy się pojawi i co muszę sprawdzić, aby pozbyć się tego ostrzeżenia?

Przyczyną tego błędu jest to, że oczekuje się, że każda obietnica poradzi sobie z odrzuceniem obietnicy, tj. Będzie miała .catch (...) . możesz tego uniknąć, dodając .catch (...) do obietnicy w kodzie, jak podano poniżej.

Na przykład, funkcja Ptest () będzie albo postanowienie lub odrzucić obietnica na podstawie wartości globalnej zmiennej somevar

var somevar = false;
var PTest = function () {
    return new Promise(function (resolve, reject) {
        if (somevar === true)
            resolve();
        else
            reject();
    });
}
var myfunc = PTest();
myfunc.then(function () {
     console.log("Promise Resolved");
}).catch(function () {
     console.log("Promise Rejected");
});

W niektórych przypadkach pojawia się komunikat „nieobsługiwane odrzucenie obietnicy”, nawet jeśli mamy .catch (..) napisane dla obietnic. Wszystko zależy od tego, jak piszesz swój kod. Poniższy kod wygeneruje „nieobsługiwane odrzucenie obietnicy”, mimo że jesteśmy w stanie to zrobić catch.

var somevar = false;
var PTest = function () {
    return new Promise(function (resolve, reject) {
        if (somevar === true)
            resolve();
        else
            reject();
    });
}
var myfunc = PTest();
myfunc.then(function () {
     console.log("Promise Resolved");
});
// See the Difference here
myfunc.catch(function () {
     console.log("Promise Rejected");
});

Różnica polega na tym, że nie traktujesz .catch(...)jak łańcuch, ale jako osobne. Z jakiegoś powodu silnik JavaScript traktuje to jako obietnicę bez nieobsługiwanego odrzucenia obietnicy.

Dzieje się tak, gdy a Promisejest zakończone .reject()lub został wygenerowany wyjątek w asyncwykonanym kodzie i żadne .catch()nie obsłużyło odrzucenia.

Odrzucona obietnica jest jak wyjątek, który przesuwa się w kierunku punktu wejścia aplikacji i powoduje, że program obsługi błędów root generuje ten wynik.

Zobacz też

• https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Promise/reject
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/catch

Obietnice można „obsłużyć” po ich odrzuceniu. Oznacza to, że można wywołać wywołanie zwrotne odrzucenia obietnicy przed udostępnieniem modułu obsługi przechwytywania. To zachowanie jest dla mnie trochę uciążliwe, ponieważ można pisać ...

var promise = new Promise(function(resolve) {
kjjdjf(); // this function does not exist });

... iw tym przypadku obietnica zostaje odrzucona w milczeniu. Jeśli zapomnisz dodać moduł obsługi przechwytywania, kod będzie działał w trybie cichym bez błędów. Może to prowadzić do utrzymujących się i trudnych do znalezienia błędów.

W przypadku Node.js mówi się o obsłudze tych nieobsługiwanych odrzuceń Promise i zgłaszaniu problemów. To prowadzi mnie do ES7 async / czekaj. Rozważ ten przykład:

async function getReadyForBed() {
  let teethPromise = brushTeeth();
  let tempPromise = getRoomTemperature();

  // Change clothes based on room temperature
  let temp = await tempPromise;
  // Assume `changeClothes` also returns a Promise
  if(temp > 20) {
    await changeClothes("warm");
  } else {
    await changeClothes("cold");
  }

  await teethPromise;
}

W powyższym przykładzie załóżmy, że toothPromise został odrzucony (Błąd: z pasty do zębów!), Zanim getRoomTemperature został spełniony. W takim przypadku nastąpi nieobsługiwane odrzucenie obietnicy do czasu oczekiwania na zęby Promise.

Chodzi mi o to ... jeśli weźmiemy pod uwagę nieobsługiwane odrzucenie obietnicy jako problem, obietnice, które są później obsługiwane przez oczekiwanie, mogą zostać przypadkowo zgłoszone jako błędy. Z drugiej strony, jeśli uznamy, że odrzucenie odrzuconych obietnic nie jest problematyczne, uzasadnione błędy mogą nie zostać zgłoszone.

Myśli na ten temat?

Jest to związane z dyskusją w projekcie Node.js tutaj:

Domyślne zachowanie wykrywania nieobsługiwanego odrzucenia

jeśli napiszesz kod w ten sposób:

function getReadyForBed() {
  let teethPromise = brushTeeth();
  let tempPromise = getRoomTemperature();

  // Change clothes based on room temperature
  return Promise.resolve(tempPromise)
    .then(temp => {
      // Assume `changeClothes` also returns a Promise
      if (temp > 20) {
        return Promise.resolve(changeClothes("warm"));
      } else {
        return Promise.resolve(changeClothes("cold"));
      }
    })
    .then(teethPromise)
    .then(Promise.resolve()); // since the async function returns nothing, ensure it's a resolved promise for `undefined`, unless it's previously rejected
}

Wywołanie getReadyForBed spowoduje synchroniczne utworzenie ostatecznej (nie zwróconej) obietnicy - która będzie miała taki sam błąd „nieobsługiwanego odrzucenia” jak każda inna obietnica (oczywiście może to być nic, w zależności od silnika). (Uważam za bardzo dziwne, że twoja funkcja nic nie zwraca, co oznacza, że ​​twoja funkcja asynchroniczna daje obietnicę dla niezdefiniowanej.

Jeśli złożę teraz obietnicę bez połowu i dodam ją później, większość implementacji „nieobsługiwanego błędu odrzucenia” faktycznie cofnie to ostrzeżenie, gdy później to zrobię. Innymi słowy, asynchronizacja / oczekiwanie nie zmienia dyskusji o „nieobsługiwanym odrzuceniu” w żaden sposób, jaki widzę.

aby uniknąć tej pułapki, napisz kod w ten sposób:

async function getReadyForBed() {
  let teethPromise = brushTeeth();
  let tempPromise = getRoomTemperature();

  // Change clothes based on room temperature
  var clothesPromise = tempPromise.then(function(temp) {
    // Assume `changeClothes` also returns a Promise
    if(temp > 20) {
      return changeClothes("warm");
    } else {
      return changeClothes("cold");
    }
  });
  /* Note that clothesPromise resolves to the result of `changeClothes`
     due to Promise "chaining" magic. */

  // Combine promises and await them both
  await Promise.all(teethPromise, clothesPromise);
}

Pamiętaj, że powinno to zapobiegać wszelkim nieobsługiwanym odrzuceniu obietnicy.

„Przestarzałe ostrzeżenie: nieobsługiwane odrzucenia obietnic są przestarzałe”

TLDR: Obietnica ma, resolvea rejectzrobienie rejectbez haczyka do jej obsługi jest przestarzała, więc będziesz musiał mieć przynajmniej catchnajwyższy poziom.

W moim przypadku była to Obietnica bez odrzucenia ani rozstrzygnięcia, ponieważ moja funkcja Obietnicy rzuciła wyjątek. Ten błąd powoduje komunikat UnhandledPromiseRejectionWarning.

Kiedy utworzę obietnicę, wygeneruję funkcję asynchroniczną. Jeśli funkcja działa dobrze, to wywołuję RESOLVE, a następnie przepływ jest kontynuowany w module obsługi RESOLVE, a następnie. Jeśli funkcja zawiedzie, należy ją zakończyć, wywołując REJECT, a następnie przepływ jest kontynuowany w POŁOWIE.

W NodeJ są przestarzałe moduł obsługi odrzucania. Twój błąd jest tylko ostrzeżeniem i przeczytałem go w github node.js. Znalazłem to.

DEP0018: Nieobsługiwane odrzucenia obietnicy

Wpisz: Runtime

Nieobsługiwane odrzucenia obietnic są przestarzałe. W przyszłości odrzucone obietnice, które nie zostaną obsłużone, zakończą proces Node.js kodem wyjścia niezerowym.