# What is parsefloat in JavaScript

## Understanding parseFloat

In the vast universe of JavaScript, there's a handy function that you may come across called `parseFloat()`. It sounds complex, but once we break it down, you'll find it's not so scary.

`parseFloat()` is a function that we use to convert a string into a number, but not just any type of number - a floating-point number. A floating-point number is a fancy name for a number with decimal points.

Think of it like this: you're at a farmer's market and you see a sign that says "Apples - \$2.50 per pound". You only want half a pound, so you need to calculate how much you should pay. To do this, you need to work with decimal numbers (in our case, it's \$1.25). This is similar to what `parseFloat()` does. It helps JavaScript to understand numbers with decimals.

## How to Use parseFloat()

Let's dive into how `parseFloat()` works in JavaScript. The basic syntax is simple:

``````parseFloat(string)
``````

In this syntax, `string` represents the string you want to convert into a floating-point number. Here's a simple example:

``````const applePrice = "2.50";
const applePriceNumber = parseFloat(applePrice);
console.log(applePriceNumber); // Outputs: 2.5
``````

In this example, `parseFloat()` takes the string "2.50" and converts it into the number 2.5.

## Dealing With Non-Numeric Strings

What happens if the string you're trying to convert isn't a number? Let's see:

``````const notANumber = "Hello, World!";
const result = parseFloat(notANumber);
console.log(result); // Outputs: NaN
``````

In this case, `parseFloat()` can't convert "Hello, World!" into a number, so it returns `NaN`, which stands for 'Not a Number'. It's JavaScript's way of saying, "Hey, I can't do this conversion for you because this string doesn't look like a number to me."

## Handling Strings with Numbers and Text

Things get a bit more interesting when the string contains both numbers and text. Let's look at an example:

``````const mixedString = "100.50lbs of apples";
const result = parseFloat(mixedString);
console.log(result); // Outputs: 100.5
``````

In this case, `parseFloat()` starts at the beginning of the string and keeps going until it can't find any more numeric characters. It then returns the number it's found. This is like having a bag labeled "100.50lbs of apples" and you just want to know how heavy it is in pounds.

`parseFloat()` can also handle integers (numbers without decimal points). Let's see:

``````const integerString = "200";
const result = parseFloat(integerString);
console.log(result); // Outputs: 200
``````

Here, `parseFloat()` treats the string "200" as the number 200. Although it doesn't have a decimal point, `parseFloat()` can still handle it.

## Conclusion

Congratulations! You've unlocked the mysteries of `parseFloat()` in JavaScript. It's like a gatekeeper, helping you transform strings into numbers, especially those with decimal points. It's a handy tool to have in your JavaScript toolkit, whether you're calculating the price of apples, figuring out weights, or dealing with strings of numbers and text.

Remember, JavaScript is just like a farmer's market. It can be overwhelming at first with all its different functions, objects, and methods - like a market full of various fruits, vegetables, and other goods. But once you get to know each one, like our friend `parseFloat()`, you'll be able to navigate it with ease. So keep exploring, keep learning, and soon enough, you'll be a master of the JavaScript market!

## Learn to code in our 100% online programs

Altcademy coding bootcamp offers beginner-friendly, online programs designed by industry experts to help you become a coder. 85%+ of Altcademy alumni are hired within 6 months after graduation. See how we teach, or click on one of the following programs to find out more.