Q126: Type Coercion and Conversion Rules

What Interviewers Want To Evaluate

This question checks whether you understand JavaScript's conversion rules without turning the answer into trivia. Interviewers want explicit vs implicit conversion, truthy and falsy values, numeric conversion, string conversion, object-to-primitive conversion, loose equality risk, and production-safe coding style.

Senior answers should explain how to avoid ambiguity in application code while still being able to debug legacy or interview examples.

Short Interview Answer

Type coercion is JavaScript converting a value from one type to another. Explicit conversion uses APIs like String(value), Number(value), and Boolean(value). Implicit conversion happens through operators, comparisons, template strings, and conditionals. Coercion is not always bad, but production code should make important conversions explicit because implicit rules around ==, +, objects, null, undefined, and empty strings can surprise teams.

Detailed Interview Answer

JavaScript is dynamically typed, so values can move through different operations that expect different types.

String(42); // "42"
Number("42"); // 42
Boolean(""); // false

These are explicit conversions. They are usually easier to read and review.

Implicit Conversion

Implicit conversion happens when JavaScript decides a conversion is needed.

"5" * 2; // 10
"5" + 2; // "52"

The * operator expects numbers. The + operator can mean numeric addition or string concatenation.

Truthy and Falsy

Falsy values are:

false
0
-0
0n
""
null
undefined
NaN

Everything else is truthy, including empty arrays and empty objects.

Boolean([]); // true
Boolean({}); // true

Conditional Checks

Truthy checks are useful when the exact value does not matter.

if (user) {
  renderUser(user);
}

But they are risky when valid values can be falsy.

if (count) {
  renderCount(count);
}

This skips 0, which may be a valid count.

Numeric Conversion

Number conversion is strict enough for many cases.

Number("42"); // 42
Number(""); // 0
Number("abc"); // NaN

parseInt and parseFloat parse from the beginning of the string.

parseInt("10px", 10); // 10
Number("10px"); // NaN

Use the one that matches the input contract.

String Conversion

Template strings convert values to strings.

const label = `Total: ${total}`;

This is usually fine for display, but logging and user-facing formatting should still consider locale, currency, dates, and privacy.

Boolean Conversion

Double negation converts to boolean.

const hasItems = !!items.length;

Boolean(value) is more explicit.

const hasItems = Boolean(items.length);

Object to Primitive

Objects can convert to primitive values through internal conversion hooks.

const value = {
  toString() {
    return "10";
  },
};

Number(value); // 10

Advanced objects can also define Symbol.toPrimitive.

Symbol.toPrimitive

const price = {
  amount: 100,
  [Symbol.toPrimitive](hint) {
    if (hint === "number") {
      return this.amount;
    }

    return `$${this.amount}`;
  },
};

This is powerful but rarely appropriate for normal product objects because it hides behavior.

Loose Equality

Loose equality uses coercion.

"" == 0; // true
false == 0; // true
null == undefined; // true

These rules can be useful in narrow cases, but most teams prefer === for predictability.

Common Mistakes

A common mistake is treating all falsy values as absence.

const pageSize = input.pageSize || 20;

This replaces 0 even if 0 is meaningful. Use nullish coalescing when only null and undefined should default.

const pageSize = input.pageSize ?? 20;

Senior Trade-Offs

Coercion is part of the language, so senior engineers should understand it. But understanding it does not mean relying on it everywhere.

Use explicit parsing at boundaries:

query params
form input
local storage
API payloads
feature flags
environment variables

Code or Design Example

function parsePositiveInteger(value, fallback) {
  const number = Number(value);

  if (!Number.isInteger(number) || number <= 0) {
    return fallback;
  }

  return number;
}

This makes the conversion rule visible and testable.

Debugging Workflow

When coercion causes bugs:

check operator involved
check truthy or falsy assumptions
check empty string and zero
check null vs undefined
check Number vs parseInt behavior
check object-to-primitive hooks
replace implicit conversion with explicit parsing

Interview Framing

Explain explicit and implicit conversion, list falsy values, then use +, Number, and defaulting examples to show practical judgment.

Revision Notes

Coercion is automatic conversion. Use explicit conversion at boundaries and avoid loose equality unless the behavior is intentional.

Key Takeaways

JavaScript conversion rules matter most when data enters your system. Parse early, validate clearly, and avoid ambiguous defaults.

Follow-Up Questions

1. What is type coercion?
2. What is explicit conversion?
3. What are falsy values?
4. Why is [] truthy?
5. Why does "5" + 2 produce a string?
6. How does Number differ from parseInt?
7. What is Symbol.toPrimitive?
8. Why is loose equality risky?
9. When should you use ?? instead of ||?
10. Where should conversion happen in an app?

How I Would Answer This In A Real Interview

I would define coercion, list the falsy values, and compare explicit conversion with implicit operator behavior. Then I would say that senior code parses external data explicitly and avoids ambiguous defaults.