# JavaScript adding a string to a number

I was reading the re-introduction to JavaScript on MDN and in the section Numbers it said that you can convert a string to a number simply by adding a plus operator in front of it.

For example:

+"42" which would yield the number output of 42.

But further along in the section about Operators it says that by adding a string "something" to any number you can convert that number to a string. They also provide the following example which confused me:

"3" + 4 + 5 would presumably yield a string of 345 in the output, because numbers 4 and 5 would also be converted to strings.

However, wouldn't 3 + 4 + "5" yield a number of 12 instead of a string 75 as was stated in their example?

In this second example in the section about operators wouldn't the + operator which is standing in front of a string "5" convert that string into number 5 and then add everything up to equal 12? What you are talking about is a unary plus. It is different than the plus that is used with string concatenation or addition.

If you want to use a unary plus to convert and have it added to the previous value, you need to double up on it.

``````> 3 + 4 + "5"
"75"
> 3 + 4 + +"5"
12
``````

Edit:

You need to learn about order of operations:

`+` and `-` have the same precedence and are associated to the left:

`````` > 4 - 3 + 5
(4 - 3) + 5
1 + 5
6
``````

`+` associating to the left again:

``````> 3 + 4 + "5"
(3 + 4) + "5"
7 + "5"
75
``````

unary operators normally have stronger precedence than binary operators:

``````> 3 + 4 + +"5"
(3 + 4) + (+"5")
7 + (+"5")
7 + 5
12
`````` You could also use parseInt() or parseFloat(), like this:

``````> 1 + 2 + "3"
"33"
> 1 + 2 + parseInt(3)
6
``````

I think that's alot cleaner than using +"3", but that is just my opinion. The answer can be found in Ecma262.pdf section 11.6.1:

If Type(lprim) is String or Type(rprim) is String, then a. Return the String that is the result of concatenating ToString( lprim) followed by ToString(rprim).

So that will resolve all operations according to precedence, so that as soon the string is found any number, the number is converted to string.

``````4 + 3 + "5"
"75"
4 + 3 + "5" + 3
"753"
``````

To read the whole standard, go here. When you look at Step 7 and "Note 2" at The Addition operator ( + ) (§11.6.1) in the ES5 specs,

it says

If Type(lprim) is String` or Type(rprim) is String, then Return the String that is the result of concatenating ToString(lprim) followed by ToString(rprim)

NOTE 2 Step 7 differs from step 3 of the comparison algorithm for the relational operators (11.8.5), by using the logical-or operation instead of the logical-and operation.

Meaning if either `7` (`3+4`) or `"5"` (`||` not `&&`) is `typeof "string"` `toString()` is applied to both operands.

So the addition is actually applied to

`"7"` and `"5"` -> `"7" + "5" //"75"` A smple + operator in javascript is used for concatenation and not to add.

A bracket and a + operator before the string format integer variable will do the job every time.

This always works fine.

``````1 + (+"2") = 3
``````

Because placing + before string converts the string variable into number.

fiddle here: http://jsfiddle.net/xuVur/2/ In the example of 3 + 4 + "5" - the Javascript parser will do (3+4)+"5", as the 3+4 is first - so it will add 3 + 4 because they are numbers, then concatenate the string "5". When you add a number and a string in Javascript the result is always a string.

Check the experiment here - http://jsfiddle.net/xuVur/1/

``````var a = "3" + 4 + 5;
var b = 3 + 4 + "5";

\$("#result1").html(a); // prints 345
\$("#result2").html(b); //prints 75
`````` It is confusing, but binary + seems to be a rare case of a number being coerced to a string. In most cases it would be the other way round (so it's very easy to think that you don't need to be too fussy about the type)

4+"3" = "43"

4-"3" = 1