Converti NaN a 0 in javascript

C'è un modo per convertire i valori NaN su 0 senza un'istruzione if:

if (isNaN(a)) a = 0;

È molto fastidioso controllare le mie variabili ogni volta.

Puoi farlo:

a = a || 0

... che convertirà un valore da qualsiasi "falso" in 0.

I valori "falsey" sono:

• false
• null
• undefined
• 0
• "" ^{( stringa vuota )}
• NaN ^{(Non un numero)}

O questo se preferisci:

a = a ? a : 0;

... che avrà lo stesso effetto di cui sopra.

Se l'intento era quello di prova per più di un semplice NaN, allora si può fare lo stesso, ma fa un ToNumber di conversione prima.

a = +a || 0

Questo utilizza l'operatore unario + per provare a convertire ain un numero. Questo ha l'ulteriore vantaggio di convertire cose come stringhe numeriche '123'in un numero.

L'unica cosa inaspettata potrebbe essere se qualcuno passa un array che può essere convertito con successo in un numero:

+['123']  // 123

Qui abbiamo un array che ha un singolo membro che è una stringa numerica. Sarà convertito con successo in un numero.

Utilizzando una doppia tilde (doppio bit a bit NOT) - ~~- fa alcune cose interessanti in JavaScript. Ad esempio puoi usarlo al posto di Math.flooro anche come alternativa a parseInt("123", 10)! È stato discusso molto sul Web, quindi non entrerò nel motivo per cui funziona qui, ma se sei interessato: cos'è l'operatore "double tilde" (~~) in JavaScript?

Possiamo sfruttare questa proprietà di una doppia tilde per convertirla NaNin un numero e fortunatamente quel numero è zero!

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

Scrivi il tuo metodo e usalo ovunque tu voglia un valore numerico:

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

Qualcosa di più semplice ed efficace per qualsiasi cosa:

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

... che convertirà un valore da qualsiasi "falso" in 0.

I valori "falsey" sono:

• false
• null
• undefined
• 0
• "" ^{( stringa vuota )}
• NaN ^{(Non un numero)}

Invece di darti una mossa per poter continuare, perché non eseguire il backup e chiedersi perché stai incontrando una NaN in primo luogo?

Se uno degli input numerici di un'operazione è NaN, anche l'output sarà NaN. Ecco come funziona l'attuale standard IEEE in virgola mobile (non è solo Javascript). Tale comportamento è per una buona ragione : l'intenzione di fondo è di impedirti di usare un risultato fasullo senza rendertene conto.

Il modo in cui NaN funziona è se qualcosa va storto in qualche sub-sub-sub-operazione (producendo un NaN a quel livello inferiore), il risultato finale sarà anche NaN, che riconoscerai immediatamente come errore anche se il tuo la logica di gestione degli errori (lancio / cattura forse?) non è ancora completa.

NaN come risultato di un calcolo aritmetico indica sempre che qualcosa è andato storto nei dettagli dell'aritmetica. È un modo per il computer di dire "debugging necessario qui". Invece di trovare un modo per continuare comunque con un numero che non è quasi mai giusto (0 è davvero quello che vuoi?), Perché non trovare il problema e risolverlo.

Un problema comune in Javascript è che sia parseInt(...)e parseFloat(...)tornerà NaN se dato un argomento senza senso ( null, '', ecc). Risolvi il problema al livello più basso possibile anziché a un livello superiore. Quindi il risultato del calcolo complessivo ha buone probabilità di avere un senso, e non stai sostituendo un numero magico (0 o 1 o altro) con il risultato dell'intero calcolo. (Il trucco di (parseInt (foo.value) || 0) funziona solo per le somme, non per i prodotti - per i prodotti che si desidera che il valore predefinito sia 1 anziché 0, ma non se il valore specificato è davvero 0)

Forse per facilità di codifica si desidera che una funzione recuperi un valore dall'utente, lo pulisca e fornisca un valore predefinito se necessario, come questo:

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

Che ne dici di una regex ?

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

Il codice seguente ignorerà NaN per consentire un calcolo dei numeri inseriti correttamente

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>

I metodi che utilizzano isNaN non funzionano se si sta tentando di utilizzare parseInt, ad esempio:

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

Ma nel secondo caso isNaN produce false (ovvero la stringa null è un numero)

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

In breve, la stringa nulla è considerata un numero valido da isNaN ma non da parseInt. Verificato con Safari, Firefox e Chrome su 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]

utilizzando la soluzione utente 113716, che tra l'altro è ottima per evitare tutti quegli if-else l'ho implementata in questo modo per calcolare la mia casella di testo del totale parziale dall'unità della casella di testo e dalla quantità della casella di testo.

Nel processo di scrittura di numeri non numerici nelle caselle di testo unità e quantità, i loro valori vengono sostituiti da zero, quindi la registrazione finale dei dati utente non ha numeri non numerici.

     <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"/>

Prova questa semplice funzione

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