# JavaScript Convert String to Number - JavaScript

Categories:
Viewed: 149 - Published at: 2 years ago

JavaScript Convert String to Number

### Introduction

Managing data is one of the fundamental concepts of programming. Converting a Number to a String is a common and simple operation. The same goes for the other way around, converting a String to a number.

### Converting String to Number

As with the previous shown methods, JavaScript also provides functions to easily transform a String to a primitive number. These are `parseInt()`, `parseFloat()`, `Math.floor()`, `Math.ceil()`, `Unary Operator / Multiply by 1`.

• `.parseInt()` takes a String as a first argument, and a base to which that String will be converted to. This method always returns an integer.
• `.parseFloat()` takes a String as an argument, and returns the Float point number equivalent.
• `Math.floor()` is used to round an integer or floating point number. It returns the nearest integer rounded down.
• `Math.ceil()` can be used to round an integer or floating point number.
• `Unary Operator` By adding a `+` sign before a String, it will be converted into a number if it follows the right format.
• `Multiply by 1`
If a String is multiplied by the primitive number `1`, the string will become a number.

#### .parseInt()

The base can be defined by adding prefixes to the numbers we want to parse:

• No prefix - If there isn't a prefix, the radix is 10 (decimal).
• 0 - If the prefix is `0`, then the radix is 8 (octal). Though, this feature is deprecated.
• 0x - If the prefix is `0x`, then the radix is 16 (hexadecimal).

Although, we can simply add an optional argument to the method call, defining the base:

``````let str = '353';
let fltStr = '353.56';
let binStr = '7';
let nanStr = 'hello';

parseInt(str);       // 353
parseInt(fltStr);    // 353
parseInt(binStr, 2); // 111 (Binary)
parseInt(nanStr);    // NaN (Not a Number)
``````

#### .parseFloat()

``````let str = '100';
let fltStr = '100.21';
let nanStr = 'bye';

parseFloat(str);    // 353
parseFloat(fltStr); // 353.21
parseFloat(nanStr); // NaN
``````

#### Math.floor()

Surprisingly, this method can also accept Strings, making it yet a way to convert a String to an integer.

``````let str = '100';
let fltStr = '99.89';
let nanStr = 'bye';

Math.floor(str);    // 100
Math.floor(fltStr); // 99
Math.floor(nanStr); // NaN
``````

#### Math.ceil()

Very similar to the previous method, Though, this time it returns the nearest integer rounded up. The method can accept Strings, also making it a way to convert a String to a number:

``````let str = '100';
let fltStr = '100.21';
let nanStr = 'bye';

Math.ceil(str);    // 100
Math.ceil(fltStr); // 101
Math.ceil(nanStr); // NaN
``````

Keep in mind that if you're needing to parse floats then both `Math.floor` and `Math.ceil` are probably not good options since they'll always convert the strings to the nearest integer equivalent.

#### Unary Operator

As with Concatenating an Empty String, there is also a workaround that has better performance but lacks readability.

``````let str = '100';
let fltStr = '100.21';
let nanStr = 'greetings';

+str    // 100
+fltStr // 100.21
+nanStr // NaN
+'1000' // 1000
+10.25  // 10.25
``````

While concise and effective, this isn't a very well-known feature of JavaScript, so it's not advised to use since it may make your code not as easy to understand.

#### Multiplying by 1

This approach is arguably the fastest one:

``````let str = '100';
let fltStr = '100.21';
let nanStr = 'greetings';

str * 1;      // 100
fltStr * 1;   // 100.21
nanStr * 1;   // NaN
'2000' * 1;   // 2000
'102.15' * 1; // 102.15
``````

The previous two approaches work simply due to the fact that JavaScript tries to assimilate the data-types used in a statement such as addition or multiplication.

#### Using String and Number Objects

Another way of transforming a String to number or a number to String is creating a new String or Number object with the `new` keyword.

``````// Number to String
let numToStr = new String(2);   // String {'2'}

// String to Number
let strToNum = new Number('2'); // Number {2}
``````

This practice is, however, discouraged. When using primitive data the object methods should not be used to create them.
Instantiating a primitive data type with the String or Number class wrapper brings performance and memory issues.

### Conclusion

There are many valid ways of manipulating data. It is up to the programmer to decide which one they prefer, choosing performance over readability or a balance between the two. For more information, you can read the following resources:

Reference: stackabuse.com