JavaScript Type Conversion & Coercion: Implicit Coercion vs Explicit Casting

Because JavaScript is dynamically typed, values frequently transition from one data type to another during program execution. This transformation happens in two distinct ways: Explicit Type Conversion (directed intentionally by the developer) and Implicit Type Coercion (performed automatically by the JavaScript engine).

Figure 3: Summary of JavaScript 8 Falsy values and Strict (===) vs Loose (==) Equality matrix.

1. Explicit Type Conversion (Casting)

Writing clear, predictable code requires explicit conversion using built-in wrapper constructors:

A. Converting to Number

// 1. Number() constructor (Strict)
Number("42");        // 42
Number("3.14");      // 3.14
Number("");          // 0
Number("Hello");     // NaN
Number(true);        // 1
Number(false);       // 0
Number(null);        // 0
Number(undefined);   // NaN

// 2. parseInt() and parseFloat()
parseInt("100px", 10); // 100 (Parses leading digits with base-10 radix)
parseFloat("12.5rem"); // 12.5

// 3. Unary Plus Operator (+)
+"99"; // 99 (Fast concise shorthand for Number())

B. Converting to String

// 1. String() constructor
String(123);         // "123"
String(true);        // "true"
String(null);        // "null"
String(undefined);   // "undefined"

// 2. .toString() method (Fails on null & undefined!)
let num = 255;
num.toString(16);    // "ff" (Converts to hexadecimal string!)

C. Converting to Boolean (Truthy vs. Falsy)

In JavaScript, every value is intrinsically either truthy or falsy when evaluated in a boolean context:

// The ONLY 8 Falsy Values:
Boolean(false);      // false
Boolean(0);          // false
Boolean(-0);         // false
Boolean(0n);         // false (BigInt zero)
Boolean("");         // false (Empty string)
Boolean(null);       // false
Boolean(undefined);  // false
Boolean(NaN);        // false

// EVERYTHING ELSE IS TRUTHY! (Notice common beginner traps):
Boolean([]);         // TRUE! (Empty array is truthy)
Boolean({});         // TRUE! (Empty object is truthy)
Boolean("0");        // TRUE! (Non-empty string is truthy)
Boolean("false");    // TRUE! (Non-empty string is truthy)

2. Implicit Type Coercion (Engine Autopilot)

Implicit coercion occurs when operators encounter unexpected data types. JavaScript silently converts one or both operands to find common ground: