Frontend interview answer

Predict map(parseInt) Callback Arguments

HighIntermediateJavascript

By FrontendAtlas Editorial · Updated Jul 17, 2026

Output challenge

The interactive answer choices load in your browser.

Interview focus

This JavaScript interview question tests whether you can explain JavaScript map(parseInt) output: callback index becomes radix, connect it to production trade-offs, and handle common follow-up questions.

JavaScript map(parseInt) output: callback index becomes radix explanation without falling back to memorized definitions
Arrays and Array Methods reasoning, edge cases, and production failure modes
How you would answer the most likely JavaScript interview follow-up

Practice more JavaScript interview questions

Interview answer drill

Use this JavaScript interview question to rehearse a quick answer, common mistake, follow-up, and production pitfall.

Practice more JavaScript interview questions Follow JavaScript mastery study plan Open Essential 60

Deep dive

Follow the callback contract

The output is [1, NaN, NaN]. The surprising part is not how map iterates; it is the mismatch between the arguments map supplies and the arguments parseInt accepts. For every element, map invokes its callback with three values: the current element, its index, and the original array. Passing parseInt directly therefore behaves like calling parseInt(element, index, values).

parseInt uses its first argument as the string to parse and its second argument as the radix. It ignores the third array argument, but the index is significant. At index 0, radix 0 lets JavaScript infer a valid base and '1' becomes 1. At index 1, radix 1 is invalid, so the result is NaN. At index 2, binary is a valid radix, but '3' is not a valid binary digit, so that result is also NaN.

Callback call	Radix interpretation	Result
parseInt('1', 0, values)	Radix 0 requests base inference; this input is read as decimal.	1
parseInt('2', 1, values)	Radix 1 is outside the supported range of 2 through 36.	NaN
parseInt('3', 2, values)	Radix 2 is valid, but the digit 3 is not valid in binary.	NaN

The array argument is ignored by parseInt, while each index is accidentally interpreted as a radix.

JAVASCRIPT

const values = ['1', '2', '3'];

// Convert each complete string to a number.
const numbers = values.map(Number);

// Or make the parseInt contract explicit and fix the radix.
const integers = values.map(value => Number.parseInt(value, 10));

console.log(numbers);  // [1, 2, 3]
console.log(integers); // [1, 2, 3]

Choose the conversion rule, then adapt the callback

Use Number when the entire input must represent a number. For example, Number('12px') is NaN, while Number('') is 0. Use parseInt when reading an integer prefix is intentional: parseInt('12px', 10) returns 12. Supplying radix 10 makes that intention explicit and avoids relying on inference. In either case, validate the result with Number.isNaN when invalid user input is possible.

The broader lesson is about callback compatibility. A function is not automatically a safe callback just because its first parameter matches the value being iterated. Array methods may pass an index and the source array as additional arguments, and a reused function may interpret those extra values as meaningful configuration. An arrow such as value => parseInt(value, 10) acts as an adapter: it deliberately forwards only the value and supplies the radix the conversion requires. Before passing any existing function directly to map, filter, or another higher-order API, compare both function contracts rather than relying on matching names or the first argument alone.