V7036. Suspicious precise comparison. Consider using a comparison with defined precision.

The analyzer has detected a code fragment where the ==, ===, !=, or !== operators are used to compare floating-point numbers. Such code may be erroneous.

The example:

let result = x * y;
if (result === 0.1) { // <= 
  ....
}

The condition result === 0.1 will almost never be true. The reason is that JavaScript, as per the IEEE 754 standard, can only represent the number 0.1 as its closest possible approximation: 0.1000000000000000055511151231257827021181583404541015625. It is very unlikely that arithmetic operations will produce exactly the same result.

To fix this, compare the difference between the values against a defined precision:

let result = x * y;
if (Math.abs(result - 0.1) < Number.EPSILON) { // <= 
  ....
}

This approach works well for numbers of small orders of magnitude (for more details on this issue, see the official documentation: Number.EPSILON). A broader option is to compare both the absolute and relative errors between two numbers:

function nearlyEqual(a, b,
                     relEpsilon = 4 * Number.EPSILON,
                     absEpsilon = Number.EPSILON
) {
  if (a === b) {
    return true;
  }

  if (Number.isNaN(a) || Number.isNaN(b)) {
    return false;
  }

  let difference = Math.abs(a - b);

  if (difference <= absEpsilon) {
    return true;
  }
  
  let maxAbsoluteValue = Math.max(Math.abs(a), Math.abs(b)); 
  return difference / maxAbsoluteValue <= relEpsilon;
}

let result = x * y;
if (nearlyEqual(result, 0.1)) { 
  ....
}

This diagnostic rule is classified as: