How to Parseint a String with Leading 0

Java ParseInt() - Catching Strings with a leading zero

Check if the first character is 0 :

if (original.charAt(0)=='0')

if (original.startsWith("0"))

If the String starts with a 0, you don't want to call parseInt at all.

I think that comparing a single character is more efficient than using regular expressions.

How to parseInt a string with leading 0

include the radix:

parseInt("09", 10);

Why javascript parseInt ignoring leading zeros in the string?

An int cannot have leading zeroes, since they don't have any mathematical meaning.

To store a number, languages use a binary representation (don't forget everything is 0s and 1s in the end). This representation is the same for 9, 09, or 00009. When the number must be printed, it is converted back to a string representation, so you lose the leading zeroes.

If you need to store/remember the 0s, your only choice is to store the string representation of the number.

What you could do is storing both the number and string representation, like this:

function MyInt(s){
    this.asString = s;
    this.num = parseInt(s);
}

var i = new MyInt("09");
console.log(i.num); // 9
console.log(i.asString); // 09

Take note that leading 0 don't have any value for int. If want to use for display purpose use string and for calculation part use parseInt(someval)

Javascript parseInt() with leading zeros

This is because if a number starts with a '0', it's treated as base 8 (octal).

You can force the base by passing the base as the 2nd parameter.

parseInt("09", 10) // 9

According to the docs, the 2nd parameter is optional, but it's not always assumed to be 10, as you can see from your example.

Parseint with leading zero Java

The error specifies that the NumberFormatException is for " 024" since the character was not removed, try this to get the variation:

String variation = number.substring(0,i) + number.substring(i+1);

How to convert a string (with leading zero or not) to an integer?

There are several ways to convert a string to a number, I prefer to use the unary + operator:

var number = +"08"; // 8

This is the equivalent of writing:

var number = Number("08"); // 8

Unlike parseInt(), when using + or Number() no radix is necessary because the internal number conversion will not parse octal numbers. If you want the parseInt() or parseFloat() methods, it's also pretty simple:

var number = parseInt("08", 10); // 8

parseInt and parseFloat are less reliable for user input because an invalid numeric literal might be considered salvageable by these functions and return an unexpected result. Consider the following:

parseInt("1,000");   // -> 1, not 1000
+"1,000";            // -> NaN, easier to detect when there's a problem

Extra Reading

Number() - MDC
Converting to number (JavaScript Type-Conversion) - jibbering.com

How do I retain leading zeroes in an Integer/Number in JavaScript?

You can't have a number with leading zeroes in Javascript, because, as Randy Casburn said, they don't have any value. You have to convert it to a string and use String.padStart() to pad the string with zeroes. parseInt will work with leading zeroes. For example:

(294).toString().padStart(6, "0") --> "000294"

parseInt("000294") --> 294

Keep Starting 0’s in JS - parseInt() function

Decimal integers cannot have leading zeroes. If you want to preserve the "prefix" after parsing, you would have to wrap the original value with an object or create a class to store the information you will need for presentation.

You could create a class that accepts an integer with a suffix/prefix and stores those for printing.

class FormattedInteger {
  constructor(formatted) {
    const [, prefix = '', value = 0, suffix = '' ] =
      formatted.match(/^([^[1-9]*]*)(\d+)([^\d*]*)$/);
    this._prefix = prefix;
    this._value = parseInt(value, 10);
    this._suffix = suffix; 
  }
  get value() {
    return this._value;
  }
  toString() {
    return `${this._prefix}${this._value}${this._suffix}`;
  }
}

var int1 = new FormattedInteger('000562');
console.log(int1.toString()); // 000562
console.log(int1.value);      // 562

var int2 = new FormattedInteger('562');
console.log(int2.toString()); // 562
console.log(int2.value);      // 562

.as-console-wrapper { top: 0; max-height: 100% !important; }