JavaScript – Type Conversions

In JavaScript, type conversion refers to changing the type of a value from one data type to another. This process can happen explicitly (manually) or implicitly (automatically by JavaScript). Understanding type conversions is essential for writing predictable and bug-free code.

What is Type Conversion?

Type conversion means changing the data type of a value. JavaScript supports:

• Explicit conversion: Manually done using global functions.
• Implicit conversion: Automatically done by JavaScript (aka type coercion).

Example:

let result = '5' + 2; // "52" → string concatenation

Explicit Type Conversion

You can manually convert types using:

String Conversion

String(123);      // "123"
(123).toString(); // "123"

Number Conversion

Number("123");    // 123
parseInt("42px"); // 42
parseFloat("3.14"); // 3.14

Boolean Conversion

Boolean(1);   // true
Boolean(0);   // false
Boolean("");  // false

Implicit Type Conversion (Type Coercion)

JavaScript tries to guess the type based on the operation.

Examples:

'5' + 2;       // "52"  → string
'5' - 2;       // 3     → number
true + 1;      // 2     → boolean to number
false + '5';   // "false5"
null + 1;      // 1     → null to number
undefined + 1; // NaN   → undefined to number

Conversion to String

JavaScript converts values to strings in string operations.

String(42);      // "42"
String(true);    // "true"
String(null);    // "null"
String(undefined); // "undefined"
[1,2] + [3];     // "1,23"  → array to string

Conversion to Number

Values converted using:

Number("5");       // 5
Number("5.5");     // 5.5
Number(true);      // 1
Number(false);     // 0
Number(null);      // 0
Number(undefined); // NaN

Unary + Operator:

+'123';  // 123
+true;   // 1
+false;  // 0

Conversion to Boolean

Values that become false (falsy):

• false
• 0, -0
• "" (empty string)
• null
• undefined
• NaN

Everything else is true (truthy):

Boolean("hello");  // true
Boolean(42);       // true
Boolean([]);       // true

Common Pitfalls in Type Conversion

Best Practices

Use strict equality === to avoid type coercion.
Convert explicitly when comparing or performing calculations.
Avoid comparing different types unless necessary.
Use helper functions like Number(), Boolean(), or String().

Summary

FAQ – JavaScript Type Conversions

What’s the difference between == and ===?

== checks for value after type coercion, while === checks for value and type without coercion.

Why is '5' + 1 not 6?

Because + with a string performs concatenation, not addition.

Can I prevent implicit type conversion?

Not entirely, but using === and explicit conversions (Number(), Boolean()) helps avoid it.

What does null + 1 return?

1, because null is coerced to 0.

Why does undefined + 1 return NaN?

undefined cannot be coerced to a valid number.