I want to check if a string contains only digits. I used this:
var isANumber = isNaN(theValue) === false;
if (isANumber){
...
}
But, realized that it also allows + and -. Basically, I want to make sure an input contains ONLY digits and no other characters. Since +100 and -5 are both numbers, isNaN() is not the right way to go. Perhaps a regexp is what I need? Any tips?
how about
let isnum = /^\d+$/.test(val);
\d is exactly equivalent to [0-9].
/^\d*$/ instead, if you find an empty string containing only digits.
000000001string.match(/^[0-9]+$/) != null;
String.prototype.isNumber = function(){return /^\d+$/.test(this);}
console.log("123123".isNumber()); // outputs true
console.log("+12".isNumber()); // outputs false
isNumber = () => /^\d+$/.test(this); instead, and use as console.log(isNumber("123123));
If you want to even support for float values (Dot separated values) then you can use this expression :
var isNumber = /^\d+\.\d+$/.test(value);
\d+ to \d*?, it will be able to match 0 - 9, as well as numbers such as .333
var isNumber = /^\d*\.?\d+$/.test(value) -- matches '3.5', '.5', '3' -- does not match '3.'
-100.2Here's another interesting, readable way to check if a string contains only digits.
This method works by splitting the string into an array using the spread operator, and then uses the every() method to test whether all elements (characters) in the array are included in the string of digits '0123456789':
const digits_only = string => [...string].every(c => '0123456789'.includes(c));
console.log(digits_only('123')); // true
console.log(digits_only('+123')); // false
console.log(digits_only('-123')); // false
console.log(digits_only('123.')); // false
console.log(digits_only('.123')); // false
console.log(digits_only('123.0')); // false
console.log(digits_only('0.123')); // false
console.log(digits_only('Hello, world!')); // false
true for empty string '', and an empty array [], an array of integers [1, 2, 3] (once they are < 10). It's more prone to bugs/misuse than the basic regular expression /^\d+$/ I think
Here is a solution without using regular expressions:
function onlyDigits(s) {
for (let i = s.length - 1; i >= 0; i--) {
const d = s.charCodeAt(i);
if (d < 48 || d > 57) return false
}
return true
}
where 48 and 57 are the char codes for "0" and "9", respectively.
This is what you want
function isANumber(str){
return !/\D/.test(str);
}
isANumber() is a misleading function name -- a valid number may contain a positive/negative sign or a dot as a decimal point separating character.in case you need integer and float at same validation
/^\d+\.\d+$|^\d+$/.test(val)
function isNumeric(x) {
return parseFloat(x).toString() === x.toString();
}
Though this will return false on strings with leading or trailing zeroes.
Well, you can use the following regex:
^\d+$
if you want to include float values also you can use the following code
theValue=$('#balanceinput').val();
var isnum1 = /^\d*\.?\d+$/.test(theValue);
var isnum2 = /^\d*\.?\d+$/.test(theValue.split("").reverse().join(""));
alert(isnum1+' '+isnum2);
this will test for only digits and digits separated with '.' the first test will cover values such as 0.1 and 0 but also .1 , it will not allow 0. so the solution that I propose is to reverse theValue so .1 will be 1. then the same regular expression will not allow it .
example :
theValue=3.4; //isnum1=true , isnum2=true
theValue=.4; //isnum1=true , isnum2=false
theValue=3.; //isnum1=flase , isnum2=true
If you want to leave room for . you can try the below regex.
/[^0-9.]/g
If you use jQuery:
$.isNumeric('1234'); // true
$.isNumeric('1ab4'); // false
let output=Number.isInteger( Number(input) );
if(output) console.log('Input string contains only numbers');
else console.log('Input string contains does not contain only numbers');
This checks non-Latin (aka non-English) digits too:
/^\p{digit}+$/u.test("1234۱۲۳۴"); // true
// OR
/^\p{Nd}+$/u.test("1234۱۲۳۴"); // true
const isdigit=(value)=>{
const val=Number(value)?true:false
console.log(val);
return val
}
isdigit("10")//true
isdigit("any String")//false
c="123".match(/\D/) == null #true
c="a12".match(/\D/) == null #false
If a string contains only digits it will return null
