## JavaScript: Fast Numeric String Testing

Sometimes I have strings that (should) contain numbers (like ‘31415’) but I want/need to test them before I use them. If this happens in a loop I could start asking myself questions about performance. And if it is a long loop an a Node.js server the performance may actually matter.

For the purpose of this post I have worked with positives (1,2,3,…), and I have written code that finds the largest valid positive in an array. Lets say there are a few obvious options:

```// Parse it and test it
const nv = +nc;
pos = Number.isInteger(nv) && 0 < nv;

// A regular expression
pos = /^[1-9][0-9]*\$/.test(nc);

// A custom function
const strIsPositive = (x) => {
if ( 'string' !== typeof x || '' === x ) return false;
const min = 48; // 0
const max = 57; // 9
let   cc  = x.charCodeAt(0);
if ( cc <= min || max < cc ) return false;
for ( let i=1 ; i<x.length ; i++ ) {
cc = x.charCodeAt(i);
if ( cc < min || max < cc ) return false;
}
return true;
}
pos = strIsPositive(nc);```

Well, I wrote some benchmark code and ran it in Node.js, and there are some quite predictable findings.

It is no huge difference between the alternatives above, but there are differences (1ms for 10000 validations, on a 4th generation i5).

There is no silver bullet, the optimal solution depends on.

If all you want is validation, it is wasteful to convert (+nc). A Regular expression is faster, but you can easily beat a Regular expression with a simple loop.

If most numbers are valid, converting to number (+nc) makes more sense. It is expensive to parse invalid values to NaN.

If you are going to use the number, converting to number (+nc) makes sense (if you convert only once).

The fastest solution, both for valid and invalid numbers, is to never convert to number (but use the custom function above to validate) and find the max using string compare.

```if ( strIsPositive(nc) &&
( max.length < nc.length ) || ( max.length === nc.length && max < nc )
)
max = nc; ```

This is obviously not a generally good advice.

### Other numeric formats

My above findings are for strings containing positives. I have tested both code that only validates, and code that use the value by comparing it.

You may not have positives but:

• Naturals, including 0, which creates a nastier regular expression but an easier loop.
• Integers, including negative values, which creates even nastier regular expressions.
• Ranged integers, like [-256,255], which probably means you want to parse (+nc) right away.
• Decimal values
• Non standard formats (with , instead of . for decimal point, or with delimiters like spaces to improve readability)
• Hex, scientific formats, whatever

In the end readability is usually more important than performance.