You should iterate over the elements of the data array and print to the console the number of values in the array that are not NaN in Javasacript

So here is my solution:

let data = [11, null, NaN, 'Hello', 24]

let check = 0;

for (item in data) {
  if (isNaN(item) == false) {
    check +=1
  };
};

console.log(check);

How ever the answer comes five, even though it is 2. I believe isNaN() function gives true or false, so why is it not working?

The in in item in data checks the properties of an object. In an array, the keys are numbers, you have five entries, so you get five times not isNan().

You want to iterate the array, so it should be let item of data

for...in loops over the properties of an object. To loop over an array's elements, use for...of or Array#forEach.

For this specific case, Array#reduce is particularly appropriate.

<!-- begin snippet: js hide: false console: true babel: false -->

<!-- language: lang-js -->

let data = [11, null, NaN, 'Hello', 24];
let res = data.reduce((a, b) => a + !isNaN(b), 0);
console.log(res);

<!-- end snippet -->

Your code returns 5 because for...in iterates over the array keys. And the array keys of data are the numbers between and including 0 and 4. Five in total, all of them are numbers.

There are multiple ways to write the code.

Using for...in, use item as an index in data (because this is what it is):
<!-- begin snippet: js hide: false console: true babel: false -->
<!-- language: lang-js -->
const data = [11, null, NaN, 'Hello', 24]

let check = 0;
for (item in data) {
    if (isNaN(data[item]) == false) {
        check += 1;
    }
}

console.log(check);

<!-- end snippet -->

Using for...of, item is a value from data and the rest of your code works fine:
<!-- begin snippet: js hide: false console: true babel: false -->
<!-- language: lang-js -->
const data = [11, null, NaN, 'Hello', 24]

let check = 0;
for (item of data) {
    if (isNaN(item) == false) {
        check += 1;
    }
}

console.log(check);

<!-- end snippet -->

Using Array.forEach() you get both the index and the value as arguments of the callback function. The value is the first argument, the index is not needed (but it is available as the second argument):
<!-- begin snippet: js hide: false console: true babel: false -->
<!-- language: lang-js -->
const data = [11, null, NaN, 'Hello', 24]

let check = 0;
data.forEach((item) => {
    if (isNaN(item) == false) {
        check ++;
    }
});

console.log(check);

<!-- end snippet -->

The callback function used by Array.forEach() changes a variable that is neither received as argument, nor a local variable of the callback function. The code is somewhat confusing this way and it is not properly encapsulated. While this is fine because there is not better option, here it can be done better using Array.reduce(). Array.reduce() seems to be closer to what the program wants to achieve than Array.forEach() (that is just a cleaner way to write the two for loops attended before).
<!-- begin snippet: js hide: false console: true babel: false -->
<!-- language: lang-js -->
const data = [11, null, NaN, 'Hello', 24]

let check = data.reduce(
    (acc, item) => {
        if (isNaN(item) == false) {
            acc ++;
        }
        return acc;
    },
    0
);

console.log(check);

<!-- end snippet -->

However, Array.reduce() is still a wrong fit. The purpose of the code is to count the numbers from the data array. A more natural way is to not count them but to extract the numbers into a new array using Array.filter(). The array itself tells us how many items it contains by accessing its .length property. There is no need for ifs:
<!-- begin snippet: js hide: false console: true babel: false -->
<!-- language: lang-js -->
const data = [11, null, NaN, 'Hello', 24]

const check = data.filter((item) => !isNaN(item)).length;

console.log(check);

<!-- end snippet -->

Other remarks

Do not put semicolons (;) after the close brace } of a code block. The semicolon is a statement separator and a code block can be used wherever a statement can be used. All in all the following piece of code

if (true) {
};

... contains two statements. One is if (true) with an empty code block on the if branch, the other is an empty statement that follows the code block until the semicolon.

It does not have any undesired effect here but it can be the source of hidden bugs difficult to find.

The semicolon is required only after some JavaScript statements. For all the others, a new line works the same as a semicolon. More than that, the JavaScript interpreter is able to insert some missing semicolons automagically.

Attention! I do not say to never use semicolons. Use them where they must be used but be aware that a missing semicolon is either inserted by the interpreter or flagged as a syntax error (and the program does not start) while an extra semicolon in the wrong place can make your program behave in an unexpected way.

Do not use == and !=. They do loose comparisons (f.e. 2 == '2') and sometimes they have surprising results. Always use the strict equality operator (===) and the strict inequality operator (!==). They first check the types of the two operands and do not do confusing conversions to check the values.

x += 1 is usually written x ++. Be aware that, in some contexts, x ++ is has different side effects than ++ x.

There is nothing wrong with += 1, just nobody uses it.

Sometimes, using the logical NOT operator (!) the code becomes more clear. It is abused by many developers that produce "clever" but unclear code but using it here is better than comparing against false.

To me, if (! isNaN(item)) seems easier to understand than if (isNaN(item) === false). It can almost be read: "if item is not NaN" vs. "if item is not NaN is false".<br>
It does not make any difference to the interpreter though. Write the code to be easy to read and understand. The computer does not care.