Qual è la differenza tra parseInt () e Number ()?

Come si comportano parseInt()e si Number()comportano diversamente quando si convertono le stringhe in numeri?

Bene, sono semanticamente diversi , il Numbercostruttore chiamato come funzione esegue la conversione del tipo ed parseIntesegue l' analisi , ad esempio:

// parsing:
parseInt("20px");       // 20
parseInt("10100", 2);   // 20
parseInt("2e1");        // 2

// type conversion
Number("20px");       // NaN
Number("2e1");        // 20, exponential notation

Tieni presente che se parseIntrileva uno zero iniziale sulla stringa, analizzerà il numero in base ottale, questo è cambiato su ECMAScript 5, la nuova versione dello standard, ma ci vorrà molto tempo per ottenere le implementazioni del browser (è incompatibilità con ECMAScript 3), parseIntignorerà anche i caratteri finali che non corrispondono a nessuna cifra della base attualmente utilizzata.

Il Numbercostruttore non rileva ottali:

Number("010");         // 10
parseInt("010");       // 8, implicit octal
parseInt("010", 10);   // 10, decimal radix used

Ma può gestire i numeri in notazione esadecimale, proprio come parseInt:

Number("0xF");   // 15
parseInt("0xF"); //15

Inoltre, un costrutto ampiamente utilizzato per eseguire la conversione di tipo numerico, è l' operatore unario +(p. 72) , equivale a utilizzare il Numbercostruttore come funzione:

+"2e1";   // 20
+"0xF";   // 15
+"010";   // 10

typeof parseInt("123") => number
typeof Number("123") => number
typeof new Number("123") => object (Number primitive wrapper object)

i primi due ti daranno prestazioni migliori in quanto restituisce una primitiva anziché un oggetto.

Se stai cercando prestazioni, probabilmente i migliori risultati otterrai con il giusto spostamento bit a bit "10">>0. Moltiplica anche ( "10" * 1) o no ( ~~"10"). Tutti sono molto più veloci di Numbere parseInt. Hanno anche "feature" che restituisce 0 per argomento non numerico. Ecco i test delle prestazioni .

Ho trovato due link di prestazioni confronto tra i diversi modi di conversione stringa int.

parseInt(str,10)    
parseFloat(str)
str << 0
+str
str*1 
str-0
Number(str)

http://jsben.ch/#/zGJHM

http://phrogz.net/js/string_to_number.html

Una differenza minore è ciò di cui convertono undefinedo null,

Number() Or Number(null) // returns 0

mentre

parseInt() Or parseInt(null) // returns NaN

Sommario:

parseInt():

• Prende una stringa come primo argomento, il radix (Un numero intero che è la base di un sistema numerico, ad es. Decimale 10 o binario 2) come secondo argomento
• La funzione restituisce un numero intero, se il primo carattere non può essere convertito in un numero NaNverrà restituito.
• Se la parseInt()funzione incontra un valore non numerico, interromperà il resto della stringa di input e analizzerà la parte solo fino al valore non numerico.
• Se la radice è undefinedo 0, JS assumerà quanto segue:
  • Se la stringa di input inizia con "0x" o "0X", la radice è 16 (esadecimale), il resto della stringa viene analizzato in un numero.
  • Se il valore di input inizia con uno 0, la radice può essere 8 (ottale) o 10 (decimale). Quale radix viene scelto dipende dall'implementazione del motore JS. ES5specifica che 10 dovrebbe essere usato allora. Tuttavia, questo non è supportato da tutti i browser, quindi specifica sempre radix se i tuoi numeri possono iniziare con uno 0.
  • Se il valore di input inizia con qualsiasi numero, la radice sarà 10

Number():

• Il Number()costruttore può convertire qualsiasi input di argomento in un numero. Se il Number()costruttore non può convertire l'input in un numero, NaNverrà restituito.
• Il Number()costruttore può anche gestire un numero esadecimale, che deve iniziare 0x.

Esempio:

console.log(parseInt('0xF', 16));  // 15

// z is no number, it will only evaluate 0xF, therefore 15 is logged
console.log(parseInt('0xFz123', 16));

// because the radix is 10, A is considered a letter not a number (like in Hexadecimal)
// Therefore, A will be cut off the string and 10 is logged
console.log(parseInt('10A', 10));  // 10

// first character isnot a number, therefore parseInt will return NaN
console.log(parseInt('a1213', 10));


console.log('\n');


// start with 0X, therefore Number will interpret it as a hexadecimal value
console.log(Number('0x11'));

// Cannot be converted to a number, NaN will be returned, notice that
// the number constructor will not cut off a non number part like parseInt does
console.log(Number('123A'));

// scientific notation is allowed
console.log(Number('152e-1'));  // 15.21

Uso sempre parseInt, ma attenzione agli zero iniziali che lo costringeranno in modalità ottale .

parseInt() -> Analizza un numero in redix specificato.

Number()-> Converte il valore specificato nel suo equivalente numerico o NaN se non riesce.

Quindi per convertire un valore non numerico in numero dovremmo sempre usare la funzione Number ().

per esempio.

Number("")//0
parseInt("")//NaN

Number("123")//123
parseInt("123")//123

Number("123ac") //NaN,as it is a non numeric string
parsInt("123ac") //123,it parse decimal number outof string

Number(true)//1
parseInt(true) //NaN

Ci sono vari casi d'angolo nelle parseInt()funzioni così come nella conversione di redix, quindi dovremmo evitare di usare la funzione parseInt () per scopi di coesione.

Ora, per controllare il tempo il valore fornito è Numerico o no, dovremmo usare la isNaN()funzione nativa

parseInt converte in un numero intero, ovvero rimuove i decimali. Il numero non viene convertito in intero.

È una buona idea stare lontano da parseInt e usare Number e Math.round a meno che tu non abbia bisogno di hex o ottale. Entrambi possono usare le stringhe. Perché starne alla larga?

parseInt(0.001, 10)
0

parseInt(-0.0000000001, 10)
-1

parseInt(0.0000000001, 10)
1

parseInt(4000000000000000000000, 10)
4

Macella completamente numeri molto grandi o molto piccoli. Stranamente funziona normalmente se questi input sono una stringa.

parseInt("-0.0000000001", 10)
0

parseInt("0.0000000001", 10)
0

parseInt("4000000000000000000000", 10)
4e+21

Invece di rischiare duramente di trovare bug con questo e gli altri personaggi citati, eviterei semplicemente parseInt a meno che non sia necessario analizzare qualcosa di diverso dalla base 10. Numero, Math.round, Math.foor e .toFixed (0) possono tutti fare le stesse cose per cui parseInt può essere usato senza questi tipi di bug.

Se vuoi davvero o hai bisogno di usare parseInt per alcune delle sue altre qualità, non usarlo mai per convertire float in ints.