Type Conversion and Casting: Handle Input Safely

A teacher enters 35 into a text field. A program reading that field receives the string '35', even though the teacher intended a number. Adding five without dealing with the type can produce the text 355.

Type conversion creates a value of another type. An explicit conversion is requested in the code, such as JavaScript’s Number. Implicit conversion, also called coercion, is performed automatically by a language operation. Neither kind proves the resulting value is valid for the task.

In JavaScript, Number(enteredScience) returns a numeric value when the text can be converted. You can store that result under another name while keeping the original string for a validation message or report.

This is different from reassigning a variable. Conversion produces a value; assignment decides where that value will be stored. It is also different from a type annotation, which gives a checker information rather than changing a runtime value.

The prerequisites are numbers, strings and booleans and type rules. Every operation below is labeled with its language because conversion behavior differs between languages.

This complete program uses JavaScript. Predict all three output lines before revealing the trace. Number requests conversion, + performs the operation allowed by its operands, and typeof reports the original input’s type.

The first sample starts with text 35 and the second with text 20. The player explains prepared states for the displayed programs. It models a supplied text value; it does not read a form or run your own code.

In the first output instruction, the string '35' leads JavaScript’s + to join text. The number 5 is converted to text, and the two strings become '355'. The operation does not guess that the teacher intended a corrected mark.

The next instruction explicitly creates numeric 35. Adding numeric 5 then gives 40. An explicit conversion makes this intention visible, but you must still inspect whether conversion succeeded and whether the mark is allowed.

Do not rely on changing the arithmetic operator to make input “work.” Different operators have different conversion rules. Use a clear conversion and validation policy before performing arithmetic.

This JavaScript example shows why conversion alone is insufficient. An empty string and a whitespace-only string convert to zero. Unsuitable text such as 'forty' or '35 marks' converts to NaN, short for “Not a Number.”

NaN is a special value within JavaScript’s number type, not a separate primitive type. The text 'Infinity' converts to Infinity, which is numeric but not a finite school mark. These are language-specific rules described in the Number documentation.

A genuine zero mark must remain acceptable, while a missing entry should get a useful message. Check the original input’s presence as well as the converted result.

This JavaScript teaching example validates one supplied text value. trim() removes whitespace from its ends. The first condition checks whether anything remains; === tests equality. Number.isFinite accepts a finite number and rejects NaN and Infinity.

The ! symbol means “not,” and || means “or.” The range condition rejects a mark below 0 or above 50. if and else if choose the first matching branch; the final else displays an accepted mark. Only one branch prints a result.

The school in this example permits fractional marks. If a different school requires whole marks, add a separate Number.isInteger rule. See the finite-number check and later conditional statements for these operations.

The complete validation program is reproduced above. Change only enteredScience to compare the following cases; each follows the same rule.

• '0': not blank, converts to finite zero, and is in range. It prints 0.
• ' ': trimming produces an empty string. The first branch prints “Enter a mark.” instead of accepting the converted zero.
• 'forty': conversion produces NaN. The second branch prints “Enter a finite number.”
• '55': conversion succeeds, but the range branch prints “Enter a mark from 0 to 50.”
• '35.5': this fictional school permits fractions, so it prints 35.5.

These messages represent different problems. Do not replace every rejected entry with zero; that would turn missing or invalid information into an apparently real result.

Parsing reads text according to a format. In this JavaScript example, parseInt reads an integer prefix. The argument 10 selects decimal notation. It stops before the decimal point or the word “marks,” so both inputs can produce 35.

Number converts the whole numeric text instead. It preserves the fractional numeric value in '35.5' and produces NaN for '35 marks'. Integer-prefix parsing would silently discard information the school may need.

Use a parser when its format matches your task. It is not a universal validator. In particular, parseInt should not be chosen merely to make an unsuitable input stop producing an error.

In JavaScript, Boolean uses truthiness rules. A nonempty string such as 'false' converts to true. An empty string or numeric zero converts to false. The letters inside a nonempty string are not interpreted as a boolean instruction.

If a school form supplies a fixed yes/no choice, interpret those allowed options explicitly. Do not use Boolean(text) to decide whether a teacher typed “yes” or “no.” Unsupported choices still need validation. See JavaScript’s Boolean rules and truthy and falsy values.

This complete JavaScript example converts the identifier '007' into a number and then back into text using String. The final text is '7', not the original identifier.

Once the numeric value has been created, it does not remember how many leading zeros were present. Keep identifiers as strings when their formatting matters. Likewise, discarding a fraction does not record the removed part for a future conversion.

The word cast is used differently across languages. Some numeric casts create a converted value. A TypeScript type assertion instead tells the checker to treat a value as a stated type; it does not convert the runtime data.

This complete example uses TypeScript. The unknown annotation says the checker does not yet know what kind of value should be assumed. The as number assertion then asks it to trust a numeric interpretation without checking the text.

const enteredScience: unknown = '35';
const science = enteredScience as number;
console.log(science + 5);

Expected output when the emitted JavaScript runs: 355. The original runtime value is still a string, so JavaScript joins text. A successfully checked assertion has not performed the conversion. Use a real conversion and validation when input is text, and do not use an assertion to hide a mismatch. See TypeScript’s assertion documentation.

Use the complete validator shown above. A teacher reports that zero marks should be accepted, but empty text should not. Explain whether the order of checks accomplishes this, then predict the output for '0', '' and 'Infinity'.

Conversion success is not task success. Numeric 55 is a successful conversion but an invalid mark out of 50. An initially valid mark of 49 would also exceed the maximum after a correction of five. Check results at the point where the school rule must hold.

A finite number can still be unsuitable. The school may require whole marks or a narrower range. Very large integers can exceed JavaScript Number’s safe precision, and fractional arithmetic has representation limits discussed in the basic types lesson.

These are teaching examples of supplied strings. They do not implement a real browser form, trusted server validation or saving records. A production application also enforces its input rules where data is accepted and stored. The lesson’s aim is to make the conversion and validation decisions explicit.

Explicit conversion creates a value of another type. Automatic conversion follows the language’s operation rules. In JavaScript, quoted marks can join text with + until converted.

Check presence, finiteness and the task’s range separately. Preserve genuine zero, reject invalid input with a useful message, and remember that parsing or conversion can discard formatting or fractions. A TypeScript assertion is not a runtime conversion.

Explain how the validator handles blank text, zero and 55. Then continue to arithmetic operations. Review type checking when deciding which mistakes a tool can catch before execution.