Conversione esadecimale in float in javascript

Questa domanda mi ha fatto porre la seguente domanda.

Mi piacerebbe convertire un numero in base 10 con una frazione in un numero in base 16.

var myno = 28.5; var convno = myno.toString( 16 ); alert( convno ); 

va tutto bene ora voglio convertirlo di nuovo in decimale.
Ma ora non posso scrivere

 var orgno = parseInt( convno, 16 ); alert( orgno ); 

Poiché non restituisce la parte decimale.

E non è ansible utilizzare parseFloat, poiché per MDC è la syntax di parseFloat

 parseFloat(str); 

Non sarebbe stato un problema se dovessi riconvertire in int, dato che la syntax di parseInt lo è

 parseInt(str [, radix]); 

Quindi, qual è un’alternativa per questo?

Disclaimer: ho pensato che fosse una domanda banale ma googling non mi ha dato risposte.

Un’altra possibilità è di analizzare separatamente le cifre, suddividendo la stringa in due e trattando entrambe le parti come inti durante la conversione e quindi aggiungendole nuovamente.

 function parseFloat(str, radix) { var parts = str.split("."); if ( parts.length > 1 ) { return parseInt(parts[0], radix) + parseInt(parts[1], radix) / Math.pow(radix, parts[1].length); } return parseInt(parts[0], radix); } var myno = 28.4382; var convno = myno.toString(16); var f = parseFloat(convno, 16); alert(myno + " -> " + convno + " -> " + f ); 

Ho combinato le risposte di Mark e Kent per creare una funzione parseFloat sovraccaricata che accetta un argomento per la radice (molto più semplice e versatile):

 function parseFloat(string, radix) { //split the string at the decimal point string = string.split(/\./); //if there is nothing before the decimal point, make it 0 if (string[0] == '') { string[0] = "0"; } //if there was a decimal point & something after it if (string.length > 1 && string[1] != '') { var fractionLength = string[1].length; string[1] = parseInt(string[1], radix); string[1] *= Math.pow(radix, -fractionLength); return parseInt(string[0], radix) + string[1]; } //if there wasn't a decimal point or there was but nothing was after it return parseInt(string[0], radix); } 

Spero che questo aiuti qualcuno!

Prova questo.

stringa può essere dati grezzi (testo semplice) con 4 caratteri (0 – 255) o stringa esadecimale “0xffffffff” lunghezza 4 byte

jsfiddle.net

 var str = '0x3F160008'; function parseFloat(str) { var float = 0, sign, order, mantiss,exp, int = 0, multi = 1; if (/^0x/.exec(str)) { int = parseInt(str,16); }else{ for (var i = str.length -1; i >=0; i -= 1) { if (str.charCodeAt(i)>255) { console.log('Wrong string parametr'); return false; } int += str.charCodeAt(i) * multi; multi *= 256; } } sign = (int>>>31)?-1:1; exp = (int >>> 23 & 0xff) - 127; mantissa = ((int & 0x7fffff) + 0x800000).toString(2); for (i=0; i 

Prova questo:

  1. Decidi quante cifre di precisione hai bisogno dopo il punto decimale.
  2. Moltiplica il tuo numero originale con quella potenza di 16 (ad es. 256 se vuoi due cifre).
  3. Converti come numero intero.
  4. Inserire il punto decimale manualmente in base a ciò che si è deciso nel passaggio 1.

Invertire i passaggi per riconvertire.

  1. Prendi il punto decimale, ricordando dove si trovava.
  2. Converti l’esadecimale in decimale in forma intera.
  3. Dividere il risultato per la potenza appropriata di 16 (16 ^ n, dove n è il numero di cifre dopo il punto decimale che hai preso nel passaggio 1).

Un semplice esempio:

Converti decimale 23.5 in esadecimale e desideri una cifra dopo il punto decimale dopo la conversione.

23,5 x 16 = 376.

Convertito in hex = 0x178.

Risposta in base 16: 17.8

Ora riconvertire in decimale:

Elimina il punto decimale: 0x178

Converti in decimale: 376

Dividi per 16: 23.5

Per favore prova questo:

 function hex2dec(hex) { hex = hex.split(/\./); var len = hex[1].length; hex[1] = parseInt(hex[1], 16); hex[1] *= Math.pow(16, -len); return parseInt(hex[0], 16) + hex[1]; } 

Non sono sicuro del formato esadecimale che avresti voluto analizzare, era qualcosa del tipo: “a1.2c”?

I float vengono comunemente memorizzati in formato esadecimale usando lo standard IEEE 754 . Quello standard non usa alcun punto (che non esiste in puro alfabeto esadecimale). Invece di questo ci sono 3 gruppi di bit di lunghezza predefinita (1 + 8 + 23 = 32 bit in totale – doppio uso 64 bit).

Ho scritto la seguente funzione per analizzare questi numeri in float:

 function hex2float(num) { var sign = (num & 0x80000000) ? -1 : 1; var exponent = ((num >> 23) & 0xff) - 127; var mantissa = 1 + ((num & 0x7fffff) / 0x7fffff); return sign * mantissa * Math.pow(2, exponent); }