I'm wondering what happens behind the scenes when we either add, subtract or multiply two strings of numbers. Here is an example:

```
let strNum1 = "300";
let strNum2 = "22";
let multiply = function(num1, num2) {
let product = num1 * num2;
return `${product}`
};
multiply(strNum1, strNum2); //this will return ==> "6600"
```

Does the JS engine turns these into integers first and then performs the operations or does it know "magically" that they are numbers even though it's in a string form? The reason I'm asking is because of the long multiplication algorithm. For numbers bigger than 8 chars it becomes funky when multiplying with the operator vs using the algorithm.

This is a leetcode question btw.

·
Juan Pablo Isaza

You can parse your values before and after operation:

```
let multiply = function(num1 = '', num2 = '') {
const product = Number(num1) * Number(num2);
return `${product}` // Or String(product)
};
```

·
Juan Pablo Isaza
Report

To answer your question: The JS Engine turns those strings into integers before doing the arithmetic operation. It is called `Implicit coercion`

.

You can read more about that in this You Don't Know JS Chapter.

·
Juan Pablo Isaza
Report

In case of addition (`+`

), When a number is added to a string, JavaScript converts the number to a string before concatenation but in case of other arithmetic operations like `*`

, `-`

, `/`

JS engine implicitly convert the string into integer.

Demo **:**

```
let result;
// numeric string used with + gives string type
result = '3' + '2';
console.log(result, typeof result) // "32", "string"
// numeric string used with - , / , * results number type
result = '3' * '2';
console.log(result, typeof result) // 6, "number"
result = '3' - '2';
console.log(result, typeof result) // 1, "number"
result = '3' / '2';
console.log(result, typeof result) // 1.5, "number"
```

·
Juan Pablo Isaza
Report