Some confusing JavaScript programs related to data types

Some confusing JavaScript programs related to data types often asked in interviews, along with sorted explanations:

1. NaN Comparisons:

console.log(NaN === NaN);
console.log(NaN == NaN);

Explanation: Both comparisons return false. In JavaScript, NaN is not equal to itself.

2. null vs. undefined:

console.log(null == undefined);
console.log(null === undefined);

Explanation: null == undefined is true due to type coercion, but null === undefined is false because they are different types.

3. String to Boolean:

console.log('false' == false);

Explanation: This prints true. JavaScript performs type coercion, converting 'false' to false for the comparison.

4. Comparing Arrays:

console.log([] == []);

Explanation: This returns false. Arrays are reference types, and == compares references, not contents.

5. typeof NaN:

console.log(typeof NaN);

Explanation: typeof NaN returns 'number'. It’s a historical quirk.

6. The delete Operator:

var obj = { name: 'John' };

Explanation: delete removes the name property from obj. Accessing afterward returns undefined.

7. Object Property Names:

var obj = { 1: 'One', 2: 'Two' };

Explanation: Property names are converted to strings. obj[1] and obj['1'] are equivalent.

8. Object Equality:

var obj1 = { a: 1 };
var obj2 = { a: 1 };

console.log(obj1 === obj2);

Explanation: obj1 and obj2 are distinct objects, so the comparison returns false.

9. NaN in Arrays:

var arr = [2, NaN, 'Hello', NaN, 42];

Explanation: arr.indexOf(NaN) returns 1 because NaN is not equal to itself, so it finds the first occurrence.

10. parseFloat Behavior:


Explanation: This parses the initial part of the string as a floating-point number, resulting in 3.14. The second '15' is not part of the valid number.

11. The in Operator:

console.log('x' in { x: undefined });

Explanation: This returns true. The in operator checks for the presence of a property, regardless of its value.

12. Array length Property:

var arr = [1, 2, 3];
arr.length = 0;

Explanation: This logs undefined. Setting arr.length to 0 removes all elements, leaving an empty array.

13. Object Keys Order:

var obj = { b: 2, c: 3, a: 1 };

Explanation: The order of keys in the result may not match the order of property insertion. In this case, it could be ['b', 'c', 'a'] or another order.

14. parseInt Behavior:


Explanation: parseInt('07') treats '07' as an octal number, so it converts it to decimal, resulting in 7.

15. JSON Serialization:

var obj = { x: [10, undefined, null] };

Explanation: JSON.stringify omits undefined values, so the resulting string is {"x":[10,null]}.

16. Function Name Property:

function foo() {}

Explanation: returns 'foo', which is the name of the function.

17. Global Variables Inside Functions:

var x = 10;

function foo() {
  var x = 20;


Explanation: JavaScript has function-level scope and hoists variables. The local var x inside foo is hoisted and shadowing the global x, so it logs undefined.

18. The arguments Object:

function foo() {

foo(1, 2, 3);

Explanation: This code logs 3. The arguments object holds the number of arguments passed to the function.

19. Prototypal Inheritance:

function Parent() {}
function Child() {}

Child.prototype = new Parent();

var child = new Child();
console.log(child instanceof Parent);

Explanation: The child is an instance of Child, but due to prototypal inheritance, it’s also considered an instance of Parent.

20. null and Object Creation:

var obj = Object.create(null);

Explanation: This code throws an error because Object.create(null) creates an object without a prototype, so it doesn’t have a toString method.

21. Function Declarations vs. Expressions:


function foo() {
  return 'Hello, Foo!';

var bar = function() {
  return 'Hello, Bar!';

Explanation: foo is a function declaration and is hoisted. bar is a

22. typeof Array:

console.log(typeof []);

Explanation: This returns 'object', which is often unexpected. Arrays are a special type of object in JavaScript.

23. typeof null:

console.log(typeof null);

Explanation: This returns 'object'. It’s a historical quirk and considered a bug in JavaScript.

24. Symbol Comparison:

const sym1 = Symbol('foo');
const sym2 = Symbol('foo');

console.log(sym1 === sym2);

Explanation: Symbols are always unique, so sym1 and sym2 are not equal, resulting in false.

25. undefined in Ternary Operator:

console.log(undefined ? 'true' : 'false');

Explanation: This prints 'false'. In a ternary operator, undefined is treated as false.

26. Function Name Property with Arrow Function:

const func = () => {};

Explanation: This prints an empty string ''. Arrow functions do not have a name property.

27. Math.min() and Math.max() with Arrays:

console.log(Math.min([10, 5, 20]));
console.log(Math.max([10, 5, 20]));

Explanation: Both statements return NaN. Math.min() and Math.max() expect individual arguments, not arrays.

28. Number Function with Strings:


Explanation: This returns NaN. Number() attempts to convert the string to a number, but it fails for non-numeric strings.

29. undefined as a Variable Name:

var undefined = 'Hello';

Explanation: This logs 'Hello'. You can assign a value to a variable named undefined.

30. Changing this with bind():

const obj = {
  x: 42,
  getX: function() {
    return this.x;

const unboundGetX = obj.getX;
const boundGetX = unboundGetX.bind(obj);


Explanation: This logs undefined. When unboundGetX is called, this is not bound to obj. Binding obj using bind() fixes the issue.

31. Parsing null with parseInt:


Explanation: This returns NaN. parseInt() expects a string argument.

32. Number.isNaN():


Explanation: The first statement returns false. Number.isNaN() is strict and only returns true for NaN values.

33. Object Destructuring with Missing Properties:

const { a, b } = { a: 1 };
console.log(a, b);

Explanation: This logs 1 undefined. Destructuring assigns undefined to b because b doesn’t exist in the object.

34. The void Operator:

console.log(void 0);

Explanation: This returns undefined. The void operator evaluates its expression and returns undefined.

35. Adding Strings and Numbers:

console.log('2' + 2);
console.log('2' - 2);

Explanation: The first statement concatenates the strings, resulting in '22'. The second statement performs subtraction, resulting in 0.

36. Date Object Month Index:

const date = new Date('2022-03-10');

Explanation: This logs 2, which is the month index (0-based) for March.

37. Using typeof with null:

console.log(typeof null);

Explanation: This returns 'object'. It’s a historical quirk and considered a bug in JavaScript.

38. JSON.parse() with Double Quotes:


Explanation: This returns 'Hello'. JSON.parse() expects double-quoted strings.

39. false Equality with 0:

console.log(false == 0);

Explanation: This returns true. JavaScript performs type coercion and considers false and 0 equal.

40. The in Operator with Arrays:

const arr = [10, 20, 30];
console.log(1 in arr);

Explanation: This returns true. The in operator checks if an index exists in the array.

41. Object Literals with Duplicate Properties:

const obj = { x: 10, x: 20 };

Explanation: This logs 20. Object literals can have duplicate properties, and the last one wins.

42. parseInt with Radix:

console.log(parseInt('10', 1));
console.log(parseInt('10', 10));
console.log(parseInt('10', 16));

Explanation: The first statement returns NaN because 1 is an invalid radix. The second statement returns 10. The third statement interprets '10' as hexadecimal and returns 16.

43. Math.max() with No Arguments:


Explanation: This returns -Infinity. Math.max() returns -Infinity when no arguments are provided.

44. Multiple Spaces in Strings:

console.log('   ' == ' ');

Explanation: This returns false. While multiple spaces visually look the same, they are different characters.

45. instanceof with Arrays:

console.log([] instanceof Array);
console.log([] instanceof Object);

Explanation: Both statements return true. Arrays are instances of both Array and Object in JavaScript.

46. Adding null and a Number:

console.log(null + 42);

Explanation: This returns 42. null is converted to 0 during numeric operations.

47. Floating-Point Precision:

console.log(0.1 + 0.2 === 0.3);

Explanation: This returns false. Floating-point arithmetic can result in small precision errors.

48. Array.isArray() with null:


Explanation: This returns false. null is not considered an array.

49. Array.prototype.toString() Behavior:

const arr = [1, 2, 3];
arr.toString = function() {
  return 'Custom';

Explanation: This logs 'Custom'. When toString is defined on an array, it overrides the default behavior.

50. Number.MAX_VALUE vs. Infinity:

console.log(Number.MAX_VALUE + 1 === Infinity);

Explanation: This returns true. Adding 1 to Number.MAX_VALUE results in Infinity.