## Parse an expression

An arithmetical expression consists of 2 numbers and an operator between them, for instance:

`1 + 2`

`1.2 * 3.4`

`-3 / -6`

`-2 - 2`

The operator is one of: `"+"`

, `"-"`

, `"*"`

or `"/"`

.

There may be extra spaces at the beginning, at the end or between the parts.

Create a function `parse(expr)`

that takes an expression and returns an array of 3 items:

- The first number.
- The operator.
- The second number.

For example:

```
let [a, op, b] = parse("1.2 * 3.4");
alert(a); // 1.2
alert(op); // *
alert(b); // 3.4
```

A regexp for a number is: `-?\d+(\.\d+)?`

. We created it in previous tasks.

An operator is `[-+*/]`

. We put a dash `-`

the first, because in the middle it would mean a character range, we don’t need that.

Note that a slash should be escaped inside a JavaScript regexp `/.../`

.

We need a number, an operator, and then another number. And optional spaces between them.

The full regular expression: `-?\d+(\.\d+)?\s*[-+*/]\s*-?\d+(\.\d+)?`

.

To get a result as an array let’s put parentheses around the data that we need: numbers and the operator: `(-?\d+(\.\d+)?)\s*([-+*/])\s*(-?\d+(\.\d+)?)`

.

In action:

```
let reg = /(-?\d+(\.\d+)?)\s*([-+*\/])\s*(-?\d+(\.\d+)?)/;
alert( "1.2 + 12".match(reg) );
```

The result includes:

`result[0] == "1.2 + 12"`

(full match)`result[1] == "1"`

(first parentheses)`result[2] == "2"`

(second parentheses – the decimal part`(\.\d+)?`

)`result[3] == "+"`

(…)`result[4] == "12"`

(…)`result[5] == undefined`

(the last decimal part is absent, so it’s undefined)

We need only numbers and the operator. We don’t need decimal parts.

So let’s remove extra groups from capturing by added `?:`

, for instance: `(?:\.\d+)?`

.

The final solution:

```
function parse(expr) {
let reg = /(-?\d+(?:\.\d+)?)\s*([-+*\/])\s*(-?\d+(?:\.\d+)?)/;
let result = expr.match(reg);
if (!result) return;
result.shift();
return result;
}
alert( parse("-1.23 * 3.45") ); // -1.23, *, 3.45
```