TypeScript — TS18048: Value is possibly undefined in strict mode

Handle TS18048 by structuring code so optional values are narrowed before use, avoiding non-null assertions.

intermediatedebuggingtypescript

Symptoms

error TS18048: 'x' is possibly 'undefined'
The variable comes from an array index or a map get
Optional chaining does not silence the error and the value is used directly
Destructured optional properties warn

Possible causes

An array index or lookup can return undefined under strict index checks
A variable is assigned conditionally and used later without narrowing
A function returns T | undefined and the caller assumes T
Optional properties are destructured and used as present

Diagnosis steps

Narrow immediately after the lookup

const x = arr[i]; if (x === undefined) return; use(x)

Interpretation

Early returns make the rest of the function operate on the non-undefined type.

Provide a default with nullish coalescing

const name = user.name ?? 'anonymous'

Interpretation

A default turns a possibly-undefined value into a definite one where that is semantically correct.

Check the source of undefined

grep -n "find(\|get(\|\[.*\]" file.ts

Interpretation

Knowing whether it is an index, a map get or an optional field tells you the right narrowing strategy.

Root cause

A value typed as possibly undefined is used as if it were defined. Strict mode requires that a branch or default establish its presence first.

Fix

Narrow with a guard and early return, supply a default with nullish coalescing where absence means a fallback, or change the function contract so it cannot return undefined when the caller requires a value.

Verify the fix

Rerun the type checker and confirm the error is gone, and add a test for the undefined path to confirm the chosen behavior.

Symptom walkthrough

Under strict settings the compiler reports TS18048 for a value it knows may be undefined. The value typically comes from an array index, a map get or an optional property, and it is then used without a guard. TS18048 and TS2532 are related; both ask you to decide what happens when the value is absent before the code relies on it.

Fix in practice

Narrow the value where it is produced: return early when undefined is not acceptable, use a nullish default when absence maps to a fallback, or tighten the function signature so it returns a definite value to callers that need one. Avoid assertion operators, which defer the failure to runtime.

Verification

Rerun the type checker and confirm the error clears, then add a test that exercises the undefined path. Confirming both present and absent cases behave as designed validates the narrowing.

Diagnostic commands

Check the behavior with commands like these:

const x = arr[i]; if (x === undefined) return; use(x)
const name = user.name ?? 'anonymous'
grep -n "find(\|get(\|\[.*\]" file.ts