Kurs JavaScript i TypeScript · Moduł 1: Podstawy JavaScript

Operatory porównania i logiczne

8 min czytania ·
W tej lekcji6

W Parku Jurajskim system zabezpieczeń nieustannie podejmuje decyzje: czy ogrodzenie elektryczne ma wystarczająco dużo energii? Czy poziom bezpieczeństwa jest odpowiedni dla tego gatunku dinozaura? Czy warunki pogodowe pozwalają na otwarcie atrakcji?

JavaScript, podobnie jak system zabezpieczeń w parku, korzysta z operatorów porównania i logicznych do podejmowania decyzji w kodzie.

Operatory porównania

Operatory porównania pozwalają na porównywanie wartości i zwracają wartość logiczną (true lub false). Pracując w Parku Jurajskim, system kontroli musi nieustannie wykonywać podobne porównania:

// Operator równości (==)
let poziomZagrożenia = 3;
let maksymalnyBezpiecznyPoziom = 3;
console.log(poziomZagrożenia == maksymalnyBezpiecznyPoziom); // true - poziomy są równe

// Operator ścisłej równości (===)
let ilośćDinozaurów = "5";
let oczekiwanaIlość = 5;
console.log(ilośćDinozaurów == oczekiwanaIlość); // true - wartości są równe, ale typy różne
console.log(ilośćDinozaurów === oczekiwanaIlość); // false - różne typy (string vs number)

// Operator nierówności (!=)
let dostępneZasoby = 500;
let wymaganeZasoby = 600;
console.log(dostępneZasoby != wymaganeZasoby); // true - wartości są różne

// Operator ścisłej nierówności (!==)
let statusOgrodzenia = "aktywne";
let wymaganyStatus = "aktywne";
console.log(statusOgrodzenia !== wymaganyStatus); // false - są identyczne (te same stringi)

// Operator większości (>)
let temperaturaTropisferowa = 38; // w stopniach Celsjusza
let bezpiecznaTemperatura = 35;
console.log(temperaturaTropisferowa > bezpiecznaTemperatura); // true - temperatura jest wyższa

// Operator mniejszości (<)
let poziomWody = 80; // procent pojemności
let krytycznyPoziom = 20;
console.log(poziomWody < krytycznyPoziom); // false - poziom wody nie jest niższy od krytycznego

// Operator większy lub równy (>=)
let liczbaPracowników = 45;
let minimalnaObsada = 45;
console.log(liczbaPracowników >= minimalnaObsada); // true - dokładnie minimalna wymagana liczba

// Operator mniejszy lub równy (<=)
let obciążenieSystemu = 75; // procent
let maksymalneObciążenie = 80;
console.log(obciążenieSystemu <= maksymalneObciążenie); // true - obciążenie jest poniżej maksimum

Różnica między == i ===

W Parku Jurajskim, precyzja jest kluczowa. Podobnie w JavaScript, istnieje ważna różnica między operatorami równości:

  • == (równość) - porównuje tylko wartości, wykonując konwersję typów jeśli to konieczne
  • === (ścisła równość) - porównuje wartości i typy danych
// Przykłady z Parku Jurajskiego:

// Scenariusz 1: Konwersja z bazy danych (string) do wartości liczbowej
let raportowanaIlośćRaptorów = "6";  // dane z systemu jako string
let rzeczywistaIlośćRaptorów = 6;    // wartość liczbowa

// Porównanie z konwersją typów
if (raportowanaIlośćRaptorów == rzeczywistaIlośćRaptorów) {
  console.log("Liczby raptorów się zgadzają"); // to się wykona
}

// Porównanie bez konwersji typów
if (raportowanaIlośćRaptorów === rzeczywistaIlośćRaptorów) {
  console.log("Ten komunikat się nie wyświetli");
} else {
  console.log("Wykryto rozbieżność w typach danych!"); // to się wykona
}

// Scenariusz 2: Porównanie wartości nieznanych (null i undefined)
let nieznanyStatus = null;
let nieokreślonyStatus;  // automatycznie będzie undefined

console.log(nieznanyStatus == nieokreślonyStatus);  // true (== traktuje null i undefined jako równe)
console.log(nieznanyStatus === nieokreślonyStatus); // false (=== rozróżnia null od undefined)

Porównywanie obiektów

Podobnie jak dwa Velociraptory mogą wyglądać podobnie, ale być różnymi osobnikami, obiekty w JavaScript są porównywane przez referencję, a nie wartość:

// Dwa dinozaury o tych samych cechach, ale to różne osobniki
let raptor1 = { gatunek: "Velociraptor", wiek: 3, agresywność: "wysoka" };
let raptor2 = { gatunek: "Velociraptor", wiek: 3, agresywność: "wysoka" };

console.log(raptor1 == raptor2);  // false - różne obiekty w pamięci
console.log(raptor1 === raptor2); // false - różne obiekty w pamięci

// Przypisanie tej samej referencji
let referencjaNaRaptora = raptor1;
console.log(raptor1 === referencjaNaRaptora); // true - ta sama referencja w pamięci

Operatory logiczne

W Parku Jurajskim decyzje rzadko są proste. Czy otworzyć atrakcję? To zależy od pogody, dostępności personelu, statusu bezpieczeństwa i innych czynników. Operatory logiczne pozwalają na łączenie warunków:

// Operator AND (&&) - zwraca true tylko gdy oba warunki są true
let ogrodzenieDziała = true;
let systemŚledzeniaDinozaurów = true;
let bezpieczeństwoZapewnione = ogrodzenieDziała && systemŚledzeniaDinozaurów;
console.log(bezpieczeństwoZapewnione); // true - oba systemy działają

// Operator OR (||) - zwraca true gdy przynajmniej jeden warunek jest true
let zasilanieGłówne = false;
let zasilanieZapasowe = true;
let parkMaZasilanie = zasilanieGłówne || zasilanieZapasowe;
console.log(parkMaZasilanie); // true - przynajmniej jedno źródło zasilania działa

// Operator NOT (!) - odwraca wartość logiczną
let parkZamknięty = false;
let parkOtwarty = !parkZamknięty;
console.log(parkOtwarty); // true - przeciwieństwo zamknięcia to otwarcie

Złożone warunki logiczne

W rzeczywistości, systemy Parku Jurajskiego muszą rozważać wiele czynników jednocześnie:

// Czy możemy otworzyć wystawę z Tyranozaurami?
let pogodaOdpowiednia = true;
let personelObecny = true;
let zasilanieStabilne = true;
let wystarczająceZapasyPożywienia = false;
let wszystkieDinozauryZdrowe = true;

// Warunek otwarcia: wszystkie czynniki muszą być pozytywne
let możnaOtworzyćWystawę = pogodaOdpowiednia && personelObecny && zasilanieStabilne &&
                          wystarczająceZapasyPożywienia && wszystkieDinozauryZdrowe;
console.log(możnaOtworzyćWystawę); // false - brakuje pożywienia

// Warunek alarmu: pogoda zła LUB brak zasilania
let warunekAlarmu = !pogodaOdpowiednia || !zasilanieStabilne;
console.log(warunekAlarmu); // false - nie ma powodu do alarmu

// Złożony warunek: jeśli jest personel I (zasilanie ALBO zapasowe generatory)
let generatoryZapasoweDziałają = true;
let warunkiOperacyjne = personelObecny && (zasilanieStabilne || generatoryZapasoweDziałają);
console.log(warunkiOperacyjne); // true - podstawowe warunki są spełnione

Krótkie obwody (short-circuit evaluation)

Operatory && i || wykorzystują technikę "krótkiego obwodu", co oznacza, że drugi warunek może nie być nawet sprawdzany:

// Przykład z && (AND):
let systemBezpieczeństwa = false;

function sprawdźStatusDinozaurów() {
  console.log("Sprawdzanie lokalizacji dinozaurów...");
  return true;
}

// Gdy pierwszy warunek jest false, drugi nie jest sprawdzany
let parkBezpieczny = systemBezpieczeństwa && sprawdźStatusDinozaurów();
// W konsoli nic się nie pojawi: funkcja nie zostanie wywołana

// Przykład z || (OR):
let główneZasilanie = true;

function uruchomGeneratory() {
  console.log("Uruchamianie generatorów...");
  return true;
}

// Gdy pierwszy warunek jest true, drugi nie jest sprawdzany
let zasilanieOperacyjne = główneZasilanie || uruchomGeneratory();
// W konsoli nic się nie pojawi: funkcja nie zostanie wywołana

Wartości prawdziwe i fałszywe (truthy i falsy)

W JavaScript, nie tylko wartości logiczne (true i false) są używane w warunkach. Każda wartość ma swoją "prawdziwość":

Wartości fałszywe (falsy):

  • false
  • 0
  • "" (pusty string)
  • null
  • undefined
  • NaN

Wszystkie inne wartości są prawdziwe (truthy).

// Przykłady z Parku Jurajskiego:

// Sprawdzenie, czy dinozaur ma przypisane imię
let imięDinozaura = ""; // Brak imienia (pusty string)
if (imięDinozaura) {
  console.log("Dinozaur ma imię: " + imięDinozaura);
} else {
  console.log("Dinozaur nie ma przypisanego imienia"); // To się wykona
}

// Sprawdzenie, czy identyfikator dinozaura istnieje
let idDinozaura = 0; // ID 0 (falsy value)
if (idDinozaura) {
  console.log("Znaleziono dinozaura o ID: " + idDinozaura);
} else {
  console.log("Nie znaleziono prawidłowego ID dinozaura"); // To się wykona
}

// Sprawdzenie statusu zagrożenia (null oznacza nieznany)
let poziomZagrożenia = null;
if (poziomZagrożenia) {
  console.log("Poziom zagrożenia: " + poziomZagrożenia);
} else {
  console.log("Status zagrożenia nieznany"); // To się wykona
}

Operator warunkowy (trójargumentowy)

Operator warunkowy ? : działa jak kompaktowy if...else i jest często używany do przypisań warunkowych:

// Standardowa konstrukcja if...else
let statusWybiegu;
let liczbaRaptorów = 5;

if (liczbaRaptorów > 0) {
  statusWybiegu = "Zajęty";
} else {
  statusWybiegu = "Pusty";
}

// To samo z operatorem warunkowym
let statusWybiegu2 = liczbaRaptorów > 0 ? "Zajęty" : "Pusty";

console.log(statusWybiegu);  // "Zajęty"
console.log(statusWybiegu2); // "Zajęty"

// Bardziej złożony przykład - przydzielanie poziomu bezpieczeństwa
let gatunekDinozaura = "Tyranozaur";
let poziomBezpieczeństwa = gatunekDinozaura === "Tyranozaur" || gatunekDinozaura === "Spinozaur" ?
                          "Maksymalny" :
                          gatunekDinozaura === "Velociraptor" ?
                          "Wysoki" :
                          "Standardowy";

console.log(`Dla gatunku ${gatunekDinozaura} wymagany poziom bezpieczeństwa: ${poziomBezpieczeństwa}`);
// "Dla gatunku Tyranozaur wymagany poziom bezpieczeństwa: Maksymalny"

Operator łączenia opcjonalnego (optional chaining)

W nowszych wersjach JavaScript dostępny jest operator łączenia opcjonalnego ?., który bezpiecznie sprawdza, czy właściwość obiektu istnieje przed próbą dostępu do niej:

// Struktura danych dinozaura
let tyranozaur = {
  nazwa: "Rex",
  statystyki: {
    wiek: 8,
    waga: 8000,
    dieta: "mięsożerna"
  }
};

let triceratops = {
  nazwa: "Tricy",
  // brak statystyk
};

// Bezpieczne odczytywanie zagnieżdżonych właściwości
console.log(tyranozaur.statystyki?.waga); // 8000
console.log(triceratops.statystyki?.waga); // undefined, bez błędu

// Bez optional chaining dostalibyśmy błąd:
// console.log(triceratops.statystyki.waga); // Error: Cannot read property 'waga' of undefined

Operator łączenia null (nullish coalescing)

Operator ?? zwraca prawy operand, gdy lewy jest null lub undefined, inaczej zwraca lewy operand:

// Ustawienie domyślnych wartości dla brakujących danych
let raportBezpieczeństwa = {
  zagrożenie: 0,
  // brak statusu zasilania
};

// Używamy ?? aby zapewnić wartość domyślną gdy właściwość jest null lub undefined
let poziomZagrożenia = raportBezpieczeństwa.zagrożenie ?? "Nieznany";
let statusZasilania = raportBezpieczeństwa.zasilanie ?? "Nieokreślony";

console.log(poziomZagrożenia); // 0 (wartość 0 nie jest null ani undefined, więc zostaje zwrócona)
console.log(statusZasilania); // "Nieokreślony" (właściwość nie istnieje, więc przyjęto wartość domyślną)

// Porównanie z || (OR)
let poziomZagrożeniaOr = raportBezpieczeństwa.zagrożenie || "Nieznany";
console.log(poziomZagrożeniaOr); // "Nieznany" (0 jest falsy, więc zwrócono wartość domyślną)

Podsumowanie

Operatory porównania i logiczne w JavaScript, podobnie jak systemy decyzyjne w Parku Jurajskim, pozwalają na:

  • Porównywanie wartości i typów (==, ===, !=, !==, >, <, >=, <=)
  • Łączenie warunków (&&, ||, !)
  • Tworzenie kompaktowych wyrażeń warunkowych (? :)
  • Bezpieczne dostępy do właściwości obiektów (?.)
  • Zapewnienie wartości domyślnych dla null/undefined (??)

Dzięki tym operatorom możemy tworzyć inteligentne systemy decyzyjne, które reagują na różne warunki - podobnie jak systemy bezpieczeństwa Parku Jurajskiego muszą reagować na zmieniające się okoliczności, aby utrzymać kontrolę nad parkiem pełnym niebezpiecznych dinozaurów.

W następnej lekcji przyjrzymy się priorytetowi operatorów, czyli temu, w jakiej kolejności JavaScript wykonuje działania w złożonych wyrażeniach.

Kod do tej lekcji: index.js
// Operatory porównania i logiczne
// System bezpieczeństwa Parku Jurajskiego

// === Operatory porównania ===
console.log("=== Operatory porównania ===");

let napiecie = 10000;
let minimum = 8000;

console.log("napięcie > minimum:", napiecie > minimum);     // true
console.log("napięcie < minimum:", napiecie < minimum);     // false
console.log("napięcie >= 10000:", napiecie >= 10000);       // true
console.log("napięcie <= 5000:", napiecie <= 5000);         // false

// == vs === (równość vs ścisła równość)
console.log("\n=== == vs === ===");
console.log("5 == '5':", 5 == '5');     // true (porównuje wartości)
console.log("5 === '5':", 5 === '5');   // false (porównuje wartości I typy)
console.log("null == undefined:", null == undefined);   // true
console.log("null === undefined:", null === undefined); // false

// != vs !==
console.log("5 != '5':", 5 != '5');     // false
console.log("5 !== '5':", 5 !== '5');   // true

// === Operatory logiczne ===
console.log("\n=== Operatory logiczne ===");

let ogrodzenieAktywne = true;
let personelBezpieczny = true;
let burzaNadchodzi = false;

// AND (&&) - oba warunki muszą być true
console.log("Można otworzyć park:", ogrodzenieAktywne && personelBezpieczny);

// OR (||) - wystarczy jeden warunek true
console.log("Wymaga uwagi:", !ogrodzenieAktywne || burzaNadchodzi);

// NOT (!) - negacja
console.log("Ogrodzenie nieaktywne:", !ogrodzenieAktywne);

// Łączenie operatorów
let moznaOtworzyc = ogrodzenieAktywne && personelBezpieczny && !burzaNadchodzi;
console.log("\nDecyzja o otwarciu:", moznaOtworzyc);

// Twoje zadanie:
// 1. Sprawdź różnice między == a ===
// 2. Połącz kilka warunków operatorami && i ||

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Co zwróci porównanie 5 === '5' w JavaScript?

  2. 2. Kiedy operator logiczny && (AND) zwraca true?

Zadania praktyczne w grze

  • Klikanie w kolejności

    Ułóż wyrażenie, które sprawdza, czy dinoCount jest ściśle równe expectedCount (zmienne w tej kolejności):

  1. PytanieRóżnica == i ===
  2. PytanieOperator logiczny &&
  3. Kliknij w kolejnościSkładnia porównania ścisłego

Przydatne artykuły