# 4.4: Input Validation

## Learning Objectives

By the end of this lesson, you should:
• Be familiar with the concept of "Data Types".
• Understand what input validation means and why we use it.
• Know how to use the `Number()` function to convert a string to a number.
• Know what the `NaN` data type is.

## Introduction

So far in any of our dice-guessing games, the program doesn't restrict players from entering "bananas", 38373, or any value other than 1 to 6. In the way we've written our code so far, there may not be errors for invalid input, but there will be situations in SWE Fundamentals where invalid input causes syntax or logical errors. To preempt these errors, we may wish to guide the player by providing feedback when their input is invalid.
We will use our dice game to demonstrate input validation. We'll first see how to detect if the player typed in a number, then we'll detect if the player's number is within the desired range of 1 to 6.

## Input Data-Type Validation

When running the `main` function via clicking the submit button, the `input` parameter will always be a string data type. The `input` string may sometimes contain number characters - e.g. "5", "9383733", or a combination of letter with number characters, e.g. "abc123", but the variable will nonetheless be of type string.
How can we check if the characters in `input` are only numbers? If we expect only number characters, how can we convert `input` to be a number and not a string?

### `Number` Function

We can try to convert a variable from string to number type with the `Number` function. If the string value has only number characters in it, `Number` will transform the string into a number.
var input = '444';
var inputNum = Number(input); // inputNum is 444
In certain projects and exercises during SWE Fundamentals, we will compare the value of `input` with a number as part of program logic. This can result in unexpected errors if we do not transform `input` from string to number first.
Whenever we expect `input` to represent a number, we should always cast it to a number with `Number(input)` before using it. This will help prevent unexpected errors where `input` may not equal what we expect, for example when comparing "1" with 1.

### NaN

When we use the `Number` function to convert a value that isn't only numbers, `Number` may return a `NaN` value. NaN stands for "not a number". For example, the following code generates `NaN`.
var input = 'papayas';
Number(input);
NaN also occurs when we attempt a math operation that doesn't result in a valid number. The following are examples.
2 * 'chocolate';
'dogs' / 32;
0 / 0;
Note that `NaN` is a valid value in JavaScript, like `0` or `1`. The following examples store `NaN` in variables.
var count = NaN;
var count = 'papayas' * 12;
var input = 'papayas';
var inputCount = Number(input);

#### Number Type Validation Logic

We can use NaN to write logic like the following.
If we try to convert a value to a number and we get the result NaN, then the value is not a number.

#### Number.isNaN

To help us implement our logic above, JavaScript provides a `Number.isNaN` function that returns whether a given value has value `NaN`. This is because a direct comparison of a value with `NaN` doesn't work in JavaScript. The following code would not work as we might expect.
// this will say FALSE, which is incorrect
Number('bananas') == NaN;
The following is an example of `Number.isNaN`, which is built-in to JavaScript. `Number.isNaN` returns a boolean value.
var input = 'hello';
var result = Number(input);
console.log(Number.isNaN(result));
To complete our logic, we might add a conditional such that our code looks like the following.
This is an example of an if/else conditional. The `else` code block will be executed only when the `if` code block is not fulfilled. In this case, only when `Number(input)` is NOT "Not a Number" (meaning it IS a number), the program will execute the `else` code block to run the regular game logic. Otherwise, if `Number(input)` is "Not a Number", only the `if` code block is executed and the regular game logic within the `else` block will not.
if (Number.isNaN(Number(input))) {
myOutputValue = 'sorry please enter a number.';
} else {
// regular app logic here
}

### Input Range Validation

Now that we've verified that `input` contains only numbers, let's verify that input is between 1 and 6. We could write a long conditional like the following...
if (
input == 1 ||
input == 2 ||
// ... etc
) {
// ...
}
...or we could express this range with comparison operators less than or equal to (`<=`) and greater than or equal to (`>=`). The if conditional in both examples evaluates to `true` when `input` is between 1 and 6.
// if number is greater than or equal to 1 AND less than or equal to 6
if (input >= 1 && input <= 6) {
// number is between 1 and 6
}
Note the functionality of the 2nd example is the same as the 1st, easier to understand, and easier to write, especially when we have a wider range, for example with a 20-sided dice. There are other ways to validate a number range, for example with less than (`<`) and greater than (`>`) operators like we do below.

## Dice Game Code With Input Validation

Our dice game code looks like the following with input validation.
var rollDice = function () {
// produce a decimal between 0 and 6
var randomDecimal = Math.random() * 6;
// remove the decimal
var randomInteger = Math.floor(randomDecimal);
// add 1 to get a number between 1 and 6 inclusive
var diceNumber = randomInteger + 1;
return diceNumber;
};
var main = function (input) {
var myOutputValue = '';
// first check if input is a number
if (Number.isNaN(Number(input)) == true) {
myOutputValue = 'sorry please enter a number.';
} else {
// then check if input is between 1 and 6
if (input < 1 || input > 6) {
myOutputValue = 'sorry please enter a number from 1 - 6';
} else {
// the input is 1-6, go ahead with the dice game
var randomDiceNumber = rollDice();
if (randomDiceNumber == input) {
myOutputValue = 'you win';
} else {
myOutputValue = 'you lose';
}
}
}
return myOutputValue;
};

### Simplify Logic with Multiple `return` Statements in Single Function

You may notice that the above example has several levels of nested if and else statements. If we have more types of input validation, this can make our code unnecessarily complex. Luckily, there is a simple way to reduce complexity by using multiple `return` statements in our functions.
Notice the multiple `return` statements in the `main` function below. This simplifies our logic by reducing nesting of if and else blocks. Functions exit after `return` statements, i.e. nothing in the function is executed after `return`, making `return` statements convenient ways to exit our logic if input is invalid.
var rollDice = function () {
// produce a decimal between 0 and 6
var randomDecimal = Math.random() * 6;
// remove the decimal
var randomInteger = Math.floor(randomDecimal);
// add 1 to get a number between 1 and 6 inclusive
var diceNumber = randomInteger + 1;
return diceNumber;
};
var main = function (input) {
var myOutputValue = '';
// first check if input is a number
if (Number.isNaN(Number(input)) == true) {
myOutputValue = 'sorry please enter a number.';
return myOutputValue;
}
// then check if input is between 1 and 6
if (input < 1 || input > 6) {
myOutputValue = 'sorry please enter a number from 1 - 6';
return myOutputValue;
}
// the input is 1-6, go ahead with the dice game
var randomDiceNumber = rollDice();
if (randomDiceNumber == input) {
myOutputValue = 'you win';
return myOutputValue;
}
myOutputValue = 'you lose';
return myOutputValue;
};

## Exercises

### Add Validation to Past Game

Choose one of your previous dice game implementations and add validation logic from this module.