Type coercion is converting a value from one type to another. The distinction is who triggers it — you, or the JS engine.

Explicit coercion — you ask for it

You deliberately convert:

Number("42")     // 42
String(42)       // "42"
Boolean(0)       // false
parseInt("42px") // 42
+"42"            // 42  (unary plus — explicit-ish)

Intentional, readable, predictable.

Implicit coercion — JS does it for you

The engine converts automatically during an operation:

"5" + 3          // "53"   — + with a string → string concatenation
"5" - 3          // 2      — - has no string meaning → numeric coercion
5 + true         // 6      — true → 1
5 == "5"         // true   — == coerces operands to compare
if ("hello")     // truthy — string → boolean
`hi ${42}`       // "hi 42" — template literal coerces to string
[] + []          // ""     — arrays → primitives → strings
[] + {}          // "[object Object]"

Why implicit coercion bites

The rules are subtle and inconsistent:

• + means concatenation if either operand is a string, otherwise addition.
• == runs the abstract equality algorithm — 0 == "", 0 == false, null == undefined are all true; NaN == NaN is false.
• Objects coerce via valueOf/toString, producing surprises like [] + {}.

The rules behind it (abstract)

• ToPrimitive — objects → primitives (via valueOf/toString).
• ToNumber — ""→0, "5"→5, "abc"→NaN, true→1, null→0, undefined→NaN, []→0, [5]→5.
• ToString — numbers/booleans/arrays → string forms.
• ToBoolean — falsy values: false, 0, -0, "", null, undefined, NaN; everything else truthy.

Best practices

• Use === / !== — strict equality, no coercion. (== only deliberately, e.g. x == null to catch null and undefined.)
• Coerce explicitly — Number(x), String(x), Boolean(x) — so intent is obvious.
• Be careful with + on mixed types; validate/convert input from the DOM (always strings) and APIs.
• Lint rules (eslint eqeqeq) enforce it.

How to answer

"Explicit coercion is a deliberate conversion — Number(), String(), Boolean(). Implicit is the engine auto-converting during operations like ==, +, or an if condition. Implicit coercion follows subtle rules (ToPrimitive/ToNumber/ToString/ToBoolean) and causes classic bugs, so I prefer === and explicit conversions — coerce on purpose, not by accident."