First look at the function signature of parseInt

/**
 * Converts a string to an integer.
 * @param s The value to be resolved. If the parameter is not a string, convert it to a string (using ToString abstraction). Whitespace at the beginning of the string will be ignored.
 * @param radix An integer between 2 and 36 (the basis of the mathematical system) that represents the cardinality of the above string.
 * If this parameter is not provided, the string starting with '0x' will be recognized as a hexadecimal number
 * In other cases, different environments have different processing methods, which are generally recognized as decimal numbers
 * If 0 null undefined and so on are passed in, this parameter is not provided for processing
 * If the input is not a number, the parameter will be converted to a number. If it cannot be converted, the parameter will not be provided for processing
 * If you do not provide this parameter, different platforms may have different platforms, so please explicitly provide this parameter
 */
declare function parseInt(s: string, radix?: number): number;

You can see that parseInt actually has two parameters, one is a required s, and the type is string;
There is also an optional radius, which is used to represent the base. For example, if you fill in 10, the first parameter will be parsed into decimal. If you fill in 16, the string passed in will be parsed into sixteen mechanism. In principle, it is better to fill in all the parameters.
The return value is an integer. If the first character of the parsed parameter cannot be converted to a numeric type, NaN is returned.

A few simple examples

The following piles all return to 15

parseInt('0xF', 16);
parseInt('F', 16);
parseInt('17', 8);
parseInt(021, 8);
parseInt('015', 10); // parseInt(015, 10); return 15
parseInt(15.99, 10);
parseInt('15,123', 10);
parseInt('FXX123', 16);
parseInt('1111', 2);
parseInt('15 * 3', 10);
parseInt('15e2', 10);
parseInt('15px', 10);
parseInt('12', 13);

The following examples all return - 15

parseInt('-F', 16);
parseInt('-0F', 16);
parseInt('-0XF', 16);
parseInt(-15.1, 10);
parseInt(' -17', 8);
parseInt(' -15', 10);
parseInt('-1111', 2);
parseInt('-15e1', 10);
parseInt('-12', 13);

The following examples all return NaN

parseInt('Hello', 8); // It's not a number at all
parseInt('546', 2); // No other number is a valid binary number except "0, 1"
parseInt('zz', 35); // z is 35. It can't be 35 in base 35

Return to the example of NaN and change it

parseInt('Hello', 18); // 320, H = 17 e = 14 l = 21, resolvable He 17 * 18 ^ 1 + 14 * 18 ^ 0 = 320
// 188275, H = 17 e = 14 l = 21, the parsed hel 17 * 22 ^ 3 + 14 * 22 ^ 2 + 21 * 22 ^ 1 + 21 * 22 ^ 0 = 188275
parseInt('Hello', 22);
parseInt('546', 10); // 546 don't say that
parseInt('zz', 36); // 1295 z = 35，35 * 36 ^ 1 + 35 * 36 ^ 0 = 1295

After passing in the number, the following examples all return 4, first toString(), and then the decimal point cannot be resolved

parseInt(4.7, 10);
parseInt(4.7 * 1e22, 10); // A very large number becomes 4
parseInt(0.00000000000434, 10); // A very small number becomes 4

Recent interview questions and variations

[1,2,3].map(parseInt)
// [1, NaN, NaN]
map<U>(callbackfn: (value: T, index: number, array: ReadonlyArray<T>) => U, thisArg?: any): U[];

I think many people know the answer. In the calculation process, we need to know some map function signatures. The first parameter of map is callback function, which has three parameters. Although the third parameter is usually not used, parseInt accepts two parameters, so it runs in practice

[1, 2, 3].map((value, index) => parseInt(value, index));

The three calculation processes are

• parseInt(1, 0), decimal, return 1
• parseInt(2, 1), base cannot be 1, return NaN
• parseInt(3, 2). It is impossible to find 3 in binary. Return NaN

[1, 2, 3].filter(parseInt); //[1]
[1, 2, 3].find(parseInt); // 1
[1, 2, 3].findIndex(parseInt); // 0

Calculus process

• parseInt(1, 0), decimal processing, return 1, true value, find return 1, findIndex return 0,
• parseInt(2, 1), cardinality cannot be 1, return NaN, false value, filtered
• parseInt(3, 2), which is impossible to appear in binary, returns NaN, false value, filtered

Here, find and findIndex can be used for short-circuit operation. If they encounter true, they will exit. They can replace forEach, which cannot exit through return, but the code semantics is weak.

[1,2,3].reduce(parseInt)
// 1
reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: ReadonlyArray<T>) => T, initialValue: T): T;

There are four callback parameters of reduce, one is the value returned in the last cycle, one is the current value, one is the current value index, and one is the original array. There is no initial value involved in this problem, so the iteration starts from 2.

The two calculation processes are as follows:

• parseInt(1, 2), binary 1, is also 1 when converted to decimal system. At this time, return 1 to enter the next iteration
• parseInt(1, 3), the second iteration, the last iteration's value is 1, the current value is 3, the ternary 1, return 1

[1, 2, 3].reduceRight(parseInt);
// NaN

The signature of reduceRight is the same as that of reduce, but the iteration starts from the right.

The two calculation processes are as follows:

• parseInt(3, 2), binary 3, return NaN
• parseInt(NaN, 1), the second iteration, the last iteration value is NaN, the current value is 1, the cardinality is 1, return NaN

[1, 2, 3].some(parseInt); // true
[1, 2, 3].every(parseInt); // false

The callback function signature of some every is the same as that of map. If some has a true value, it returns true. If every is all true, it returns true.

The calculation process is

• parseInt(1, 0), decimal processing, return 1, true value, some return true, operation end
• parseInt(2, 1), cardinality cannot be 1, return NaN, false value, every return false, operation end

It is mentioned here that some and every can be used for short-circuit operation. When some encounters true, it will exit. When every encounters false, it will exit. It can be used to replace forEach, which cannot exit through return, but the code semantics is weak.

[1, 2, 3].forEach(parseInt); // true
// undefined

If the answer to this question is wrong, I really want to slap myself....

[1, 2, 3].map(parseInt); has it been type converted? Yes, we have. Because parseInt will transfer the first parameter passed in. If it is not a string, it will be converted to a string. Here is a type conversion

Written in the end

An API seems to be very simple. In fact, there are many ways to test it. If you don't understand it carefully, you won't know its principle.