In elementary JavaScript programming, you might've learned to write a function to sum two numbers like so:

` var sum = (num1, num2) => num1 + num2`

Now if you passed two numbers like `sum(2, 3)`

into the `sum()`

function, you got `5`

. Cool, right?

But what if you or someone who has access to your function only passed in one number? Like:

` sum(2) // NaN`

Really? They get "not a number" - `NaN`

?

JavaScript is expecting two arguments, as defined by the function, and it gets only one. It tries to sum it with a second, finds none, so maybe it does the summing with emptiness, I guess, because rather than throw an error, it gives you the `NaN`

result.

`undefined`

The sum of To actually see why JavaScript is giving you `NaN`

, try running

` sum('three') // threeundefined`

See? "threeundefined"?

That probably tells you that JavaScript is adding or concatenating the `String`

"three" with its `Primitive`

type `undefined`

because a variable declared but not initiated/not defined (that is, not given a value) is assigned the `undefined`

value/keyword. So, it exists (in memory, yeah), but not defined. Making sense? Now, try

` sum(undefined) // NaN`

To JavaScript, the sum of `undefined`

is `NaN`

.

How do you prevent this from happening? How do you make sure that even if only one number is supplied to your sum function, JavaScript will run as expected and give the desired result? I mean, the sum of 1 plus nothing should be 1, right?

### Restricting your function to real numeral

Just before we proceed to using `reduce()`

and the "rest parameter" to write a proper, fail-safe sum function, let me introduce a control logic into our function that'll ensure that the user supplied a real numeral number - the function should warn the programmer/user if anything other than required is supplied.

```
var sum = (num1, num2) => {
if (typeof num1 !== 'number') return 'Kindly enter a numeric number.'
return num1 + num2
}
// Now try any of these
sum(2) // NaN
sum(2, 4) // 6
sum('Three') // "Kindly enter a numeric number."
sum(undefined) // "Kindly enter a numeric number."
sum(NaN) // "Kindly enter a numeric number."
```

Now, your sum function is somewhat error-proof. But not there yet. Let's get it there, shall we?

`reduce()`

and the rest parameter to sum

Using To ensure that our `sum()`

function is robust enough to sum any number of arguments, even if only one is supplied, we define our expected parameters as a rest parameter, meaning we straight ahead write `...args`

. Then knowing how `reduce()`

works, summing things in sequence as it loops through a list/array of these things, we run `reduce`

on the array of "rest". Cool?

See what we got,

```
var sum = (...args) => args.reduce((acc, cur) => acc + cur)
// More error-proof sum()
var sum = (...args) => {
var isNotANumber = el => typeof el !== 'number'
if (args.some(isNotANumber)) return "Please enter only numeric numbers."
return args.reduce((acc, cur) => acc + cur)
}
// Now try any of these
sum(2) // 2
sum(2, 4) // 6
sum('Three') // "Kindly enter a numeric number."
sum(undefined) // "Kindly enter a numeric number."
sum(NaN) // NaN
```

And, thus, we got a nifty little "summer" helper function for us.