Convertir NaN en 0 en javascript

Existe-t-il un moyen de convertir les valeurs NaN en 0 sans instruction if:

if (isNaN(a)) a = 0;

C'est très ennuyeux de vérifier mes variables à chaque fois.

Tu peux le faire:

a = a || 0

... qui convertira une valeur "falsey" en 0.

Les valeurs de "falsey" sont:

• false
• null
• undefined
• 0
• "" ^{( chaîne vide )}
• NaN ^{(Pas un nombre)}

Ou ceci si vous préférez:

a = a ? a : 0;

... qui aura le même effet que ci-dessus.

Si l'intention était de tester plus que juste NaN, alors vous pouvez faire la même chose, mais faites d'abord une conversion toNumber .

a = +a || 0

Cela utilise l'opérateur unaire + pour essayer de convertir aen nombre. Cela a l'avantage supplémentaire de convertir des choses comme des chaînes numériques '123'en nombre.

La seule chose inattendue peut être si quelqu'un passe un tableau qui peut être converti avec succès en nombre:

+['123']  // 123

Ici, nous avons un tableau qui a un seul membre qui est une chaîne numérique. Il sera converti avec succès en nombre.

L'utilisation d'un double tilde (double bit NOT) - ~~- fait des choses intéressantes en JavaScript. Par exemple, vous pouvez l'utiliser au lieu de Math.floorou même comme alternative à parseInt("123", 10)! Cela a été beaucoup discuté sur le Web, donc je ne vais pas expliquer pourquoi cela fonctionne ici, mais si cela vous intéresse: Qu'est-ce que l'opérateur "double tilde" (~~) en JavaScript?

Nous pouvons exploiter cette propriété d'un double tilde pour la convertir NaNen nombre, et heureusement ce nombre est nul!

console.log(~~NaN); // 0

Écrivez votre propre méthode et utilisez-la partout où vous voulez une valeur numérique:

function getNum(val) {
   if (isNaN(val)) {
     return 0;
   }
   return val;
}

Quelque chose de plus simple et efficace pour tout:

function getNum(val) {
   val = +val || 0
   return val;
}

... qui convertira une valeur "falsey" en 0.

Les valeurs de "falsey" sont:

• false
• null
• undefined
• 0
• "" ^{( chaîne vide )}
• NaN ^{(Pas un nombre)}

Plutôt que de le calmer pour que vous puissiez continuer, pourquoi ne pas sauvegarder et vous demander pourquoi vous rencontrez un NaN en premier lieu?

Si l'une des entrées numériques d'une opération est NaN, la sortie sera également NaN. C'est ainsi que fonctionne la norme actuelle à virgule flottante IEEE (ce n'est pas seulement Javascript). Ce comportement est pour une bonne raison : l'intention sous-jacente est de vous empêcher d'utiliser un résultat faux sans vous rendre compte qu'il est faux.

La façon dont NaN fonctionne est que si quelque chose se passe mal dans une sous-sous-sous-opération (produisant un NaN à ce niveau inférieur), le résultat final sera également NaN, que vous reconnaîtrez immédiatement comme une erreur même si votre la logique de gestion des erreurs (lancer / attraper peut-être?) n'est pas encore terminée.

Le NaN résultant d'un calcul arithmétique indique toujours que quelque chose a mal tourné dans les détails de l'arithmétique. C'est une façon pour l'ordinateur de dire "le débogage nécessaire ici". Plutôt que de trouver un moyen de continuer de toute façon avec un nombre qui n'est presque jamais correct (0 est-il vraiment ce que vous voulez?), Pourquoi ne pas trouver le problème et le résoudre.

Un problème commun en Javascript est que les deux parseInt(...)et parseFloat(...)retourne NaN si on leur donne un argument absurde ( null, '', etc.). Résolvez le problème au niveau le plus bas possible plutôt qu'à un niveau supérieur. Ensuite, le résultat du calcul global a de bonnes chances d'avoir un sens, et vous ne remplacez pas un nombre magique (0 ou 1 ou autre) pour le résultat de tout le calcul. (L'astuce de (parseInt (foo.value) || 0) ne fonctionne que pour les sommes, pas pour les produits - pour les produits dont vous voulez que la valeur par défaut soit 1 plutôt que 0, mais pas si la valeur spécifiée est vraiment 0.)

Peut-être pour faciliter le codage, vous voulez qu'une fonction récupère une valeur de l'utilisateur, la nettoie et fournisse une valeur par défaut si nécessaire, comme ceci:

function getFoobarFromUser(elementid) {
        var foobar = parseFloat(document.getElementById(elementid).innerHTML)
        if (isNaN(foobar)) foobar = 3.21;       // default value
        return(foobar.toFixed(2));
}

Que diriez-vous d'une expression régulière ?

function getNum(str) {
  return /[-+]?[0-9]*\.?[0-9]+/.test(str)?parseFloat(str):0;
}

Le code ci-dessous ignorera NaN pour permettre un calcul des nombres correctement entrés

function getNum(str) {
  return /[-+]?[0-9]*\.?[0-9]+/.test(str)?parseFloat(str):0;
}
var inputsArray = document.getElementsByTagName('input');

function computeTotal() {
  var tot = 0;
  tot += getNum(inputsArray[0].value);
  tot += getNum(inputsArray[1].value);
  tot += getNum(inputsArray[2].value);
  inputsArray[3].value = tot;
}

<input type="text"></input>
<input type="text"></input>
<input type="text"></input>
<input type="text" disabled></input>
<button type="button" onclick="computeTotal()">Calculate</button>

Les méthodes qui utilisent isNaN ne fonctionnent pas si vous essayez d'utiliser parseInt, par exemple:

parseInt("abc"); // NaN
parseInt(""); // NaN
parseInt("14px"); // 14

Mais dans le second cas, isNaN produit false (c'est-à-dire que la chaîne nulle est un nombre)

n="abc"; isNaN(n) ? 0 : parseInt(n); // 0
n=""; isNaN(n) ? 0: parseInt(n); // NaN
n="14px"; isNaN(n) ? 0 : parseInt(n); // 14

En résumé, la chaîne nulle est considérée comme un nombre valide par isNaN mais pas par parseInt. Vérifié avec Safari, Firefox et Chrome sur OSX Mojave.

var i = [NaN, 1,2,3];

var j = i.map(i =>{ return isNaN(i) ? 0 : i});

console.log(j)

[0,1,2,3]

en utilisant la solution de l'utilisateur 113716, qui est d'ailleurs excellente pour éviter tous ceux si-sinon je l'ai implémenté de cette façon pour calculer ma zone de texte de sous-total à partir de l'unité de zone de texte et de la quantité de zone de texte.

Dans le processus d'écriture des non nombres dans les zones de texte unitaires et quantitatives, leurs valeurs sont remplacées par zéro pour que la validation finale des données utilisateur ne comporte pas de non-nombres.

     <script src="/common/tools/jquery-1.10.2.js"></script>
     <script src="/common/tools/jquery-ui.js"></script>

     <!----------------- link above 2 lines to your jquery files ------>





    <script type="text/javascript" >
    function calculate_subtotal(){

    $('#quantity').val((+$('#quantity').val() || 0));
    $('#unit').val((+$('#unit').val() || 0));

    var  calculated = $('#quantity').val() * $('#unit').val() ;
    $('#subtotal').val(calculated);


    }
    </script>


      <input type = "text" onChange ="calculate_subtotal();" id = "quantity"/>
      <input type = "text" onChange ="calculate_subtotal();" id = "unit"/>
      <input type = "text" id = "subtotal"/>

Veuillez essayer cette fonction simple

var NanValue = function (entry) {
    if(entry=="NaN") {
        return 0.00;
    } else {
        return entry;
    }
}