Kurs JavaScript i TypeScript · Moduł 1: Podstawy JavaScript
Operatory porównania i logiczne
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 maksimumRóż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ęciOperatory 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 otwarcieZł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łnioneKró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łanaWartoś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):
false0""(pusty string)nullundefinedNaN
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 undefinedOperator łą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. Co zwróci porównanie 5 === '5' w JavaScript?
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):