Come posso verificare se una stringa è un float?

Question

Sto passando un parametro chiamato valore. Mi piacerebbe sapere se il valore è un galleggiante. Finora, ho il seguente:

if (!isNaN(value)) 
{ 
    alert('this is a numeric value but not sure if it is a float.'); 
} 

Come faccio a fare un passo avanti e convertire la stringa in qualcosa che può valutare ad un galleggiante?

Answer 1

Ti piace questa:

if (!isNaN(value) && value.toString().indexOf('.') != -1) 
{ 
    alert('this is a numberic value and I\'m sure it is a float.'); 
}​ 

Answer 2

È possibile utilizzare la funzione parseFloat.

Se il valore passato è un float, la funzione restituisce il valore, altrimenti restituirà NaN.

Qualcosa di simile:

val = parseFloat(val); 
if(isNaN(val)) 
    alert("not a float!"); 

Answer 3

Solo se value viene passato come stringa possiamo pienamente determinare se si utilizza un punto decimale o no. Perché 1.0 (come numero) restituisce 1 sebbene "1.0" (come stringa) restituisca esattamente lo stesso "1.0". E da lì possiamo trovare se contiene un punto decimale, .. Quindi dobbiamo passare l'argomento value come una stringa.

_{Il seguente funziona se value è una stringa}

if (value.indexOf('.') > -1) { // value is a floating point 

} 

value.toString() non si accenderà 1.0 a "1.0" (piuttosto, sarebbe semplicemente girarlo 1) quindi passando per stringa è la migliore alternativa perché mantiene tutti i suoi personaggi.

Se non si desidera utilizzare una stringa, non è possibile acquisire 1.0 come valore a virgola mobile. Utilizzare il seguente se si vuole testare un numero di è un valore in virgola mobile:

_{Quanto segue non funzionerà per 1.0, 1.00, ecc}

if (value >>> 0 !== x) { // value is a floating point 

} 

Nota: Si dovrebbe anche controllare per !isNaN(value) (l'ho lasciato fuori per concentrarsi sulle modifiche).

Answer 4

Per controllare se una stringa è un numero intero o un float

function isFloat(n) { 
    return parseFloat(n.match(/^-?\d*(\.\d+)?$/))>0; 
} 

//alert(isFloat("3.444")); 

Answer 5

Number.prototype.isFloat = function() { 
    return (this % 1 != 0); 
} 

Poi si può

var floatValue = parseFloat("2.13"); 
var nonFloatValue = parseFloat("11"); 

console.log(floatValue.isFloat()); // will output true 
console.log(nonFloatValue.isFloat()); // will output false 

Valori come 2.00 può davvero essere considerato galleggiante in JS, o meglio ogni il numero è un float in JS.

---

EDIT: Ho dimenticato di menzionare che estendere i prototipi di tipi built-in è considerato un parctice errato (per una buona ragione) e il suo utilizzo è scoraggiato negli ambienti di produzione.È comunque possibile implementare questo controllo come una semplice funzione

Answer 6

Le seguenti funzioni controllano anche il formato. Per esempio. Le funzioni JavaScript native parseInt e parseFloat analizzano anche stringhe contenenti caratteri non numerici e le funzioni sopra riportate hanno conseguenze.

// For example, following code will work 
var n = parseInt('123asd'); 
n == 123 

Queste funzioni restituiscono false per tale stringa.

function isFloat(val) { 
    var floatRegex = /^-?\d+(?:[.,]\d*?)?$/; 
    if (!floatRegex.test(val)) 
     return false; 

    val = parseFloat(val); 
    if (isNaN(val)) 
     return false; 
    return true; 
} 

function isInt(val) { 
    var intRegex = /^-?\d+$/; 
    if (!intRegex.test(val)) 
     return false; 

    var intVal = parseInt(val, 10); 
    return parseFloat(val) == intVal && !isNaN(intVal); 
} 

Answer 7

Per verificare se una stringa è un galleggiante (evitare valori int)

function isFloat(n) { 
    if(n.match(/^-?\d*(\.\d+)?$/) && !isNaN(parseFloat(n)) && (n%1!=0)) 
     return true; 
    return false; 
} 

var nonfloat = isFloat('12'); //will return false 
var nonfloat = isFloat('12.34abc'); //will return false 
var float = isFloat('12.34'); //will return true 

Answer 8

Se avete bisogno di controllare se il valore è int o float:

function isFloatOrInt(n) { 
    return !isNaN(n) && n.toString().match(/^-?\d*(\.\d+)?$/); 
} 

Answer 9

ho scritto funzioni che accettare stringhe, numeri interi e galleggianti

function isInt(x) { 
    return !isNaN(x) && eval(x).toString().length == parseInt(eval(x)).toString().length 
} 

function isFloat(x) { 
    return !isNaN(x) && !isInt(eval(x)) && x.toString().length > 0 
} 

esempio ouptuts:

console.log(isFloat('0.2')) // true 
console.log(isFloat(0.2)) // true 
console.log(isFloat('.2')) // true 
console.log(isFloat('-.2')) // true 
console.log(isFloat(-'.2')) // true 
console.log(isFloat(-.2)) // true 
console.log(isFloat('u.2')) // false 
console.log(isFloat('2')) // false 
console.log(isFloat('0.2u')) // false 

console.log(isInt('187')) // true 
console.log(isInt(187)) // true 
console.log(isInt('1.2')) // false 
console.log(isInt('-2')) // true 
console.log(isInt(-'1')) // true 
console.log(isInt('10e1')) // true 
console.log(isInt(10e1)) // true 

Answer 10

semplice:

if (parseFloat(value).toString() === value.toString()) { 
    ... 
} 

Answer 11

Nel mio caso una semplice espressione regolare ha fatto il trucco.

Avevo bisogno di convalidare l'input di un utente se l'input è un valore monetario valido. Ho semplicemente usato-

/^[0-9]+(\.)?[0-9]*$/.test(number) 

tutto tra // è l'espressione regolare.

/^ significa che la corrispondenza inizia dall'inizio della parola e $/ significa che la corrispondenza termina con la parola. Se pensi che la parola non possa iniziare con la lettera 0 allora l'espressione sarebbe come [1-9][0-9]*

[0-9]+ significa che la parola deve iniziare con almeno un numero.

Nota: * significa zero o più, + significa uno o più e ? significa uno o nessuno.

Fino a qui l'espressione è /^[1-9][0-9]*$/ e questo convaliderà solo i numeri interi.

Per verificare per un punto (.) Nel numero, è necessario utilizzare \. con l'espressione. . è un carattere speciale che corrisponde a tutto, \. corrisponderà solo al periodo.

Infine un'altra classe di caratteri [0-9]* corrisponde a zero o più cifre.

Test Cases

/^[0-9]+(\.)?[0-9]$/.test("21.38a") // ==> false 
/^[0-9]+(\.)?[0-9]$/.test("21.38") // ==> true 
/^[0-9]+(\.)?[0-9]$/.test("y2781.68") // ==> false 
/^[0-9]+(\.)?[0-9]$/.test("2781r.68") // ==> false 

Answer 12

Questa funzione restituisce il valore numerico di una stringa, indipendentemente se int o float

function getNumericVal(str) { 
    if(isNaN(str)) return; 
    try {return parseFloat(str);} 
    catch(e) {return parseInt(str);} 
} 

Answer 13

function checkFloat(value) { 
    let parsed = Number.parseFloat(value); 
    return (!Number.isNaN(parsed)) && (!Number.isInteger(parsed)) 
} 

Answer 14

Usa questa:

var isNumber = /^\d+\.\d+$/.test(value); 

Answer 15

u se questo codice jquery

<script> 
    $(document).ready(function() { 
     $(".allow_only_float").keypress(function (e) { 

      if (e.which != 46 && e.which != 8 && e.which != 0 && (e.which < 48 || e.which > 57)) { 
       e.preventDefault();//return false; 
      } 
      var avg = $('#<%=txtAverage.ClientID%>').val(); 
      var idx = avg.indexOf("."); 
      if (idx > -1 && e.which == 46) { 
       e.preventDefault();//return false; 
      } 
     }); 
    }); 
    </script> 
<body> 
    <input type='text' class='allow_only_float'> 
</body>