@vrkr - za duck.ai:
Oto lista "głupich" rzeczy związanych z operatorami porównywania w JavaScript:
1. **Używanie `==` zamiast `===`**: Operator `==` wykonuje konwersję typów, co może prowadzić do nieoczekiwanych wyników. Zawsze lepiej używać `===`, aby porównywać zarówno wartość, jak i typ.
2. **Porównywanie różnych typów bez zrozumienia**: Porównywanie wartości różnych typów (np. liczby i stringi) może prowadzić do zaskakujących wyników, np. `0 == '0'` zwraca `true`, ale `0 === '0'` zwraca `false`.
3. **Używanie `!=` zamiast `!==`**: Podobnie jak w przypadku `==`, operator `!=` wykonuje konwersję typów, co może prowadzić do błędów. Zawsze lepiej używać `!==`.
4. **Porównywanie obiektów**: Porównywanie obiektów za pomocą operatorów porównania (np. `obj1 == obj2`) porównuje referencje, a nie zawartość obiektów, co może prowadzić do nieporozumień.
5. **Używanie `Object.is()` bez zrozumienia**: `Object.is()` ma swoje specyficzne zasady porównywania (np. `NaN` jest równe `NaN`, a `-0` nie jest równe `+0`), co może być mylące.
6. **Porównywanie wartości `null` i `undefined`**: Używanie `==` do porównania `null` i `undefined` zwraca `true`, co może prowadzić do niejasności, gdy nie jest to zamierzone.
7. **Zbyt skomplikowane wyrażenia porównawcze**: Tworzenie złożonych wyrażeń porównawczych, które są trudne do zrozumienia, może prowadzić do błędów i utrudniać czytelność kodu.
8. **Ignorowanie kontekstu logicznego**: Używanie operatorów porównania w kontekście logicznym (np. w instrukcjach warunkowych) bez zrozumienia, jak działają, może prowadzić do błędnych założeń.
9. **Porównywanie z `NaN`**: `NaN` nie jest równe żadnej wartości, w tym samemu sobie, co może prowadzić do nieoczekiwanych wyników w porównaniach.
10. **Używanie operatorów porównania w pętlach bez zrozumienia**: Używanie operatorów porównania w pętlach (np. `for`) bez zrozumienia ich działania może prowadzić do nieskończonych pętli lub błędów logicznych.
Unikanie tych pułapek może pomóc w pisaniu bardziej niezawodnego i przewidywalnego kodu w JavaScript.