Converting Text Numbers to Integers in Your Code

What converting a string to an integer means

When you have a number stored as text — like "42" or "100" — your program treats it as letters, not as a number you can do math with. Converting a string to an integer means telling your program to read that text and turn it into an actual number. After conversion, you can add it, subtract it, compare it, or use it in calculations.

This happens constantly in real programs. When someone types their age into a web form, it arrives as text. When you read a line from a file or a database, numbers often come through as strings. Your code needs to convert these before it can use them as numbers.

Key Takeaways

Every programming language has a built-in function to convert strings to integers — Python uses int(), JavaScript uses parseInt(), and Java uses Integer.parseInt().
The string must contain only digits (and optionally a minus sign for negative numbers), or the conversion will fail and your program will crash unless you handle the error.
Whitespace at the start or end of the string — spaces, tabs, line breaks — usually gets ignored automatically, so " 42 " converts the same way as "42".
If you need to convert back from an integer to a string later, every language also has a function for that, often called toString() or str().

Converting strings to integers in Python

Python's int() function is the simplest approach. You pass it the string, and it returns an integer:

text = "42" number = int(text) print(number + 8)

This prints 50, because "42" became the integer 42. If the string contains spaces at the edges, int() strips them automatically, so int(" 42 ") works fine. Negative numbers work too: int("-15") becomes -15.

If the string contains anything that is not a digit or a minus sign, Python stops and raises a ValueError. The string "42x" or "four" will crash your program. To prevent this, wrap the conversion in a try-except block:

try: number = int(text) except ValueError: print("That is not a valid number")

This catches the error and lets your program continue instead of crashing.

Converting strings to integers in JavaScript

JavaScript offers two main functions: parseInt() and Number(). They behave slightly differently, so choose based on what you need.

parseInt() reads the string from left to right and stops at the first non-digit character. So parseInt("42px") returns 42, ignoring the "px". This is useful when parsing strings that have units attached. It also requires a second argument — the base, usually 10 for decimal numbers: parseInt("42", 10).

Number() is stricter. Number("42") returns 42, but Number("42px") returns NaN (Not a Number), which signals a failed conversion. Use Number() when you want to reject any string that is not purely numeric. Check for NaN afterward with isNaN():

let number = Number(text); if (isNaN(number)) { console.log("That is not a valid number"); }

Converting strings to integers in Java

Java's Integer.parseInt() converts a string to an int. The syntax is straightforward:

String text = "42"; int number = Integer.parseInt(text);

If the string is not a valid integer, parseInt() throws a NumberFormatException. You must catch it or declare that your method throws it:

try { int number = Integer.parseInt(text); } catch (NumberFormatException e) { System.out.println("That is not a valid number"); }

Java also has Integer.valueOf(), which does the same thing but returns an Integer object instead of a primitive int. For most cases, parseInt() is what you want.

Handling strings that are not valid numbers

A string fails to convert when it contains letters, special characters, or other non-numeric content. The string "abc", "12.34.56", or even "12 34" (with a space in the middle) will all fail. Every language handles this failure differently, but the principle is the same: your code must either prevent the error or catch it when it happens.

The safest approach is to validate the string before converting. Check that it contains only digits (and optionally a minus sign at the start). Many languages have built-in methods for this. Python's str.isdigit() returns True if the string contains only digits. JavaScript's /^\d+$/.test(text) uses a regular expression to check the same thing. Java's text.matches("-?\\d+") checks for an optional minus sign followed by one or more digits.

If validation fails, either ask the user to enter a valid number, use a default value, or skip that piece of data. Never let an invalid conversion crash your program silently.

Converting integers back to strings

You will often need to go the other direction — turn an integer back into a string. This is usually simpler than converting to an integer, because every integer can be represented as a string without error.

In Python, use str(): text = str(42) produces "42". In JavaScript, use String() or the .toString() method: text = String(42) or text = (42).toString(). In Java, use Integer.toString(): String text = Integer.toString(42).

This is useful when you need to display a number to the user, store it in a file, or send it over the network. Most of the time, your language handles this conversion automatically — if you print a number or concatenate it with text, the conversion happens behind the scenes.

Common mistakes and how to avoid them

The most common mistake is forgetting to handle the error when a conversion fails. If you call int("abc") in Python without a try-except block, your program crashes. Always assume the string might be invalid and plan for it.

Another mistake is forgetting that the result is now a number, not text. After number = int("5"), the variable number holds an integer. If you later do number + "3", most languages will either crash or produce unexpected results. Keep track of what type each variable holds.

A third mistake is assuming whitespace is not there. The string " 42 " (with spaces) converts fine in Python and Java, but in some languages or contexts it might not. When reading from user input or files, always strip whitespace first to be safe. Python's int(text.strip()) removes spaces before converting.

Frequently Asked Questions

What happens if I try to convert a decimal number like "3.14"?

Most integer conversion functions will fail. Python's int("3.14") raises a ValueError. If you need to convert a decimal string, use float() first to get 3.14, then convert to int if you need to: int(float("3.14")) gives you 3 (the decimal part is dropped). JavaScript's parseInt("3.14", 10) returns 3 by stopping at the decimal point.

Can I convert a string with a plus sign, like "+42"?

Yes. Python's int("+42") works fine and returns 42. JavaScript's parseInt("+42", 10) also works. Java's Integer.parseInt("+42") accepts it. The plus sign is treated the same as no sign at all.

What if the string is empty or just whitespace?

An empty string or a string with only spaces will fail to convert in all major languages. Python raises ValueError, JavaScript returns NaN, and Java throws NumberFormatException. Check for empty strings before attempting conversion, or handle the error.

Is there a difference between converting to int and converting to a long or double?

Yes. An int holds smaller numbers (usually -2 billion to 2 billion). If your string represents a larger number, use long() in Python, BigInt() in JavaScript, or Long.parseLong() in Java. For decimals, use float() or double() depending on precision needed.

Do I need to specify the base when converting?

Only if the string is in a base other than 10 (decimal). JavaScript's parseInt() requires a base argument, so parseInt("1010", 2) converts binary to decimal (returns 10). Python's int("1010", 2) does the same. Java's Integer.parseInt("1010", 2) also works. If you omit the base or use 10, the string is treated as a regular decimal number.

This guide is for general information only and is not medical, financial, legal, or other professional advice. For decisions specific to your situation, consult a qualified professional. See our Editorial Policy.