Pourquoi un retour dans `finally` remplace` try`?

Comment fonctionne une instruction return dans un bloc try / catch?

function example() {
    try {
        return true;
    }
    finally {
        return false;
    }
}

Je m'attends à ce que la sortie de cette fonction soit true, mais c'est le cas false!

Enfin exécute toujours . C'est à cela qu'il sert, ce qui signifie que son retour est utilisé dans votre cas.

Vous voudrez changer votre code pour qu'il ressemble plus à ceci:

function example() { 
    var returnState = false; // initialisation value is really up to the design
    try { 
        returnState = true; 
    } 
    catch {
        returnState = false;
    }
    finally { 
        return returnState; 
    } 
} 

En règle générale, vous ne voulez jamais avoir plus d'une instruction return dans une fonction, ce sont des choses comme celles-ci.

Selon ECMA-262 (5ed, décembre 2009), aux pp.96:

La production TryStatement : try Block Finallyest évaluée comme suit:

1. Soit B le résultat de l'évaluation de Block.
2. Soit F le résultat de l'évaluation de Final.
3. Si F.type est normal, renvoyez B.
4. Retour F.

Et à partir des pages 36:

Le type d' achèvement est utilisé pour expliquer le comportement des déclarations ( break, continue, returnet throw) qui effectuent des transferts non locaux de contrôle. Les valeurs du type d' achèvement sont triplets de la forme (type, valeur cible) , où le type est l' un normal, break, continue, return, ou throw, la valeur est une valeur linguistique ECMAScript ou vide, et la cible est un identificateur ECMAScript ou vide.

Il est clair que return falsefixerait le type d'achèvement de finalement comme retour , ce qui cause try ... finallyà faire 4. Retour F .

Lorsque vous utilisez finally, tout code dans ce bloc se déclenche avant la fin de la méthode. Comme vous utilisez un retour dans le finallybloc, il appelle return falseet remplace le précédent return truedans le trybloc.

(La terminologie n'est peut-être pas tout à fait correcte.)

pourquoi vous obtenez false est que vous êtes retourné dans un bloc finally. Enfin, le bloc doit toujours s'exécuter. donc vos return truechangements enreturn false

function example() {
    try {
        return true;
    }
    catch {
        return false;
    }
}

Le bloc finally réécrit try block return (au sens figuré).

Je voulais juste souligner que si vous renvoyez quelque chose de finalement, il sera renvoyé par la fonction. Mais si finalement il n'y a pas de mot «return» - il sera retourné la valeur du bloc try;

function example() {
    try {
        return true;
    }
    finally {
       console.log('finally')
    }
}
console.log(example());
// -> finally
// -> true

Donc -finalement- returnréécrit le retour de -try- return.

Autant que je sache, le finallybloc s'exécute toujours , que vous ayez une returninstruction à l'intérieur tryou non. Ergo, vous obtenez la valeur renvoyée par l' returninstruction à l'intérieur du bloc finally.

J'ai testé cela avec Firefox 3.6.10 et Chrome 6.0.472.63 tous deux dans Ubuntu. Il est possible que ce code se comporte différemment dans d'autres navigateurs.

Je vais donner une réponse légèrement différente ici: Oui, le bloc tryet finallyest exécuté et finallya la priorité sur la valeur de "retour" réelle d'une fonction. Cependant, ces valeurs de retour ne sont pas toujours utilisées dans votre code.

Voici pourquoi:

• L'exemple ci-dessous utilisera res.send()Express.js, qui crée une réponse HTTP et la distribue.
• Votre tryet finallybloc sera à la fois exécuter cette fonction comme ceci:

try {
    // Get DB records etc.
    return res.send('try');
} catch(e) {
    // log errors
} finally {
    return res.send('finally');
}

Ce code affichera la chaîne trydans votre navigateur. AUSSI, l'exemple montrera une erreur dans votre console. La res.send()fonction est appelée deux fois . Cela se produira avec tout ce qui est une fonction. Le bloc try-catch-finally obscurcira ce fait à l'œil non averti, car (personnellement) j'associe uniquement des returnvaleurs aux portées de fonction.

À mon avis, votre meilleur pari est de ne jamais utiliser à l' returnintérieur d'un finallybloc . Cela compliquera trop votre code et masquera potentiellement les erreurs.

En fait, il existe une règle d'inspection de code par défaut configurée dans PHPStorm qui donne un "Avertissement" pour ceci:

https://www.jetbrains.com/help/phpstorm/javascript-and-typescript-return-inside-finally-block.html

Alors qu'est-ce que tu utilises finally?

Je n'utiliserais finallyque pour nettoyer des trucs. Tout ce qui n'est pas critique pour la valeur de retour d'une fonction.

Cela peut avoir du sens si vous y réfléchissez, car lorsque vous dépendez d'une ligne de code sous finally, vous supposez qu'il pourrait y avoir des erreurs dans tryou catch. Mais ces deux derniers sont les éléments de base de la gestion des erreurs. Utilisez simplement un returnin tryet à la catchplace.

De retour d'un bloc final

Si le finally-bloc retourne une valeur, cette valeur devient la valeur de retour de l'ensemble de la try-catch-finallydéclaration, sans tenir compte des returndéclarations du tryet catch-blocks

Référence: developer.mozilla.org

Enfin est censé s'exécuter TOUJOURS à la fin d'un bloc try catch de sorte que (par spécification) est la raison pour laquelle vous obtenez un faux retourné. Gardez à l'esprit qu'il est tout à fait possible que différents navigateurs aient des implémentations différentes.

Et ça?

doubleReturn();

function doubleReturn() {
  let sex = 'boy';

  try {
    return sex;

    console.log('this never gets called...');
  } catch (e) {} finally {
    sex = 'girl'; 

    alert(sex);
  }
}