qu'advient-il si nous n'avons pas de résoudre ou de rejeter la promesse

Une promesse est juste un objet avec des propriétés dans le Javascript. Il n'y a pas de magie. Donc, à défaut de le résoudre ou de rejeter une promesse juste ne jamais modifier l'état "en attente", rien d'autre. Cela ne cause aucun problème fondamental en Javascript car une promesse est juste un objet Javascript. La promesse sera toujours obtenir des ordures collectées (même si elles sont encore en attente) si aucun code n'conserve une référence à la promesse.

La conséquence réelle ici est ce que cela signifie pour le consommateur de la promesse si son état n'est jamais changé? Tout .then() ou .catch() auditeurs pour résoudre ou de rejeter les transitions ne sera jamais appelé. La plupart du code qui utilise des promesses attend d'eux pour résoudre ou de refuser à un certain moment dans l'avenir (c'est pourquoi les promesses sont utilisés en premier lieu). S'ils ne le font pas, alors que le code, en général, n'arrive jamais à terminer son travail.

Il est possible que vous pourriez avoir d'autres codes qui termine le travail pour cette tâche, et la promesse est juste abandonné sans jamais faire sa chose. Il n'y a pas de problème interne en Javascript si vous le faites de cette façon, mais il n'est pas combien de promesses ont été conçus pour fonctionner et n'est généralement pas comment les consommateurs de promesses s'attendre à travailler.

Comme vous pouvez le voir si le statut est en 401, je suis rediriger vers la page de connexion.
La promesse n'est ni résolu ni rejetée.

Est ce code OK? Ou est-il une meilleure façon de l'accomplir.

Dans ce cas particulier, c'est OK et une redirection est un peu spécial et unique cas. Une redirection vers une nouvelle page de votre navigateur va complètement effacer le courant de l'état de la page (y compris tous les Javascript état) de sorte qu'il est parfaitement bien de prendre un raccourci avec la redirection et il suffit de laisser d'autres choses en suspens. Le système sera complètement réinitialiser l'option Javascript de votre état lorsque la nouvelle page se charge alors de toutes les promesses qui étaient encore en suspens sera nettoyé.

OriginalL'auteur jfriend00

Je pense que le "ce qui se passe si l'on ne résout pas rejeter" a été répondu fine - c'est votre choix si vous voulez ajouter un .then ou un .catch.

Cependant, Est ce code OK? Ou est-il un meilleur moyen d'atteindre ce. Je dirais il y a deux choses:

Vous êtes d'emballage, une Promesse dans new Promise quand il n'est pas nécessaire et que la fetch appel peut échouer, vous devez agir sur de manière à ce que votre méthode d'appel n'a pas s'asseoir et d'attendre pour une Promesse qui ne sera jamais résolu.

Voici un exemple (je pense que cela devrait fonctionner pour votre entreprise logique, pas sûr à 100%):

const constants = {
  SERVER_ERROR: "500 Server Error"
};
function makeRequest(url,params) {
  //fetch already returns a Promise itself
  return fetch(url,params)
        .then((response) => {

            let status = response.status;

            //If status is forbidden, redirect to Login & return nothing,
            //indicating the end of the Promise chain
            if(status === 401) {
              redirectToLoginPage();
              return;
            }
            //If status is success, return a JSON Promise
            if(status >= 200 && status < 300) {
              return response.json();
            }
            //If status is a failure, get the JSON Promise,
            //map the message & status, then Reject the promise
            return response.json()
              .then(json => {
                if (!json.message) {
                    json.message = constants.SERVER_ERROR;
                }
                return Promise.reject({status, error: json.message});
              })
        });
}
//This can now be used as:
makeRequest("http://example", {})
  .then(json => {
    if(typeof json === "undefined") {
      //Redirect request occurred
    }
    console.log("Success:", json);
  })
  .catch(error => {
    console.log("Error:", error.status, error.message);
  })

En revanche, l'appel de votre code à l'aide de:

makeRequest("http://example", {})
  .then(info => console.log("info", info))
  .catch(err => console.log("error", err));

Ne log rien parce que l'appel à http://example va échouer, mais la catch gestionnaire ne sera jamais exécuter.

OriginalL'auteur CodingIntrigue

Que d'autres ont dit, c'est vrai que c'est pas vraiment un problème si vous n'avez pas de résoudre ou de rejeter une promesse. De toute façon j'permettrait de résoudre votre problème un peu différent:

function makeRequest(ur,params) {

    return new Promise(function(resolve,reject) {

        fetch(url,params)
        .then((response) => {

            let status = response.status;

            if (status >= 200 && status < 300) {
                response.json().then((data) => {
                    resolve(data);
                })
            }
            else {
                reject(response);
            }
        })
    });
}

makeRequest().then(function success(data) {
   //...
}, function error(response) {
    if (response.status === 401) {
        redirectToLoginPage();
    }
    else {
        response.json().then((error) => {
            if (!error.message) {
                error.message = constants.SERVER_ERROR;
            }

            //do sth. with error
        });
    } 
});

Cela signifie que je ne le rejette chaque mauvaise réponse de l'état, puis les traiter dans votre error handler de votre makeRequest.

OriginalL'auteur Fidel90