Kurs JavaScript i TypeScript · Moduł 1: Podstawy JavaScript
Priorytet operatorów
W tej lekcji7
W Parku Jurajskim, protokoły bezpieczeństwa muszą być ściśle przestrzegane i wykonywane w odpowiedniej kolejności. Na przykład, zanim otworzy się bramę do wybiegu z Tyranozaurem, należy upewnić się, że wszystkie inne drzwi są zamknięte i że pracownicy są w bezpiecznych strefach. Kolejność tych działań ma kluczowe znaczenie.
Podobnie w JavaScript, operatory mają swój priorytet (precedence), który określa kolejność ich wykonania w wyrażeniach. Zrozumienie tej hierarchii jest niezbędne do tworzenia poprawnych i przewidywalnych wyrażeń.
Czym jest priorytet operatorów?
Priorytet operatorów to reguła, która określa kolejność, w jakiej operatory są wykonywane w złożonych wyrażeniach. Operatory o wyższym priorytecie są wykonywane przed operatorami o niższym priorytecie.
Wyobraźmy sobie, że w Parku Jurajskim mamy listę zadań do wykonania z różnym priorytetem:
- Najwyższy priorytet: Sprawdzenie zasilania w ogrodzeniach elektrycznych
- Średni priorytet: Sprawdzenie ilości pożywienia dla dinozaurów
- Niski priorytet: Aktualizacja informacji dla odwiedzających
Podobnie, JavaScript ma swoją hierarchię priorytetów dla operatorów.
Tabela priorytetów operatorów
Poniżej przedstawiono uproszczoną tabelę priorytetów operatorów w JavaScript, od najwyższego do najniższego:
| Priorytet | Kategoria | Operatory |
|---|---|---|
| 19 | Grupowanie | ( ... ) |
| 18 | Dostęp do właściwości i elementy tablicy | . [] ?. |
| 17 | Wywołanie funkcji | ... ( ... ) |
| 16 | Operatory postfiksowe | ++ -- |
| 15 | Operatory prefiksowe | ! ~ + - ++ -- typeof void delete |
| 14 | Potęgowanie | ** |
| 13 | Mnożenie, dzielenie, modulo | * / % |
| 12 | Dodawanie, odejmowanie | + - |
| 11 | Przesunięcie bitowe | << >> >>> |
| 10 | Porównania (nierówności) | < > <= >= instanceof in |
| 9 | Równość | == != === !== |
| 8 | Bitowe AND | & |
| 7 | Bitowe XOR | ^ |
| 6 | Bitowe OR | | |
| 5 | Logiczne AND | && |
| 4 | Logiczne OR | || |
| 3 | Nullish coalescing | ?? |
| 2 | Operator warunkowy | ? : |
| 1 | Przypisanie | = += -= *= /= %= <<= >>= >>>= &= ^= |= **= |
| 0 | Operator przecinka | , |
Przykłady z Parku Jurajskiego
Przyjrzyjmy się, jak priorytet operatorów działa w praktyce, wykorzystując przykłady z codziennej pracy w Parku Jurajskim:
Przykład 1: Operacje arytmetyczne
// Obliczenie ilości pożywienia potrzebnego dla dinozaurów
let małeMięsożerne = 5;
let średnieMięsożerne = 3;
let dużeMięsożerne = 2;
let dzienneZużycieMałych = 50; // kg
let dzienneZużycieŚrednich = 150; // kg
let dzienneZużycieDużych = 300; // kg
// Bez nawiasów - priorytet operatorów decyduje o kolejności
let całkowitePożywienie = małeMięsożerne * dzienneZużycieMałych + średnieMięsożerne * dzienneZużycieŚrednich + dużeMięsożerne * dzienneZużycieDużych;
console.log(całkowitePożywienie); // 1300 kg
// Mnożenie (*) ma wyższy priorytet niż dodawanie (+), więc powyższe wyrażenie jest równoważne:
let całkowitePożywienie2 = (małeMięsożerne * dzienneZużycieMałych) + (średnieMięsożerne * dzienneZużycieŚrednich) + (dużeMięsożerne * dzienneZużycieDużych);
console.log(całkowitePożywienie2); // 1300 kg (ten sam wynik)Przykład 2: Operatory logiczne i porównania
// Sprawdzenie warunków otwarcia wybiegu dla zwiedzających
let temperaturaPowietrza = 28; // stopnie Celsjusza
let wilgotność = 60; // procent
let prędkośćWiatru = 15; // km/h
let poziomZagrożenia = 2; // skala 1-5
let dostępnyPersonel = 5; // liczba pracowników
let wymaganyPersonel = 3; // minimalna liczba
// Złożony warunek bez nawiasów
let otwartyWybieg = temperaturaPowietrza > 20 && wilgotność < 80 && prędkośćWiatru < 20 || poziomZagrożenia <= 2 && dostępnyPersonel >= wymaganyPersonel;
// Jak JavaScript to interpretuje? Operator && ma wyższy priorytet niż ||
// Powyższe wyrażenie jest równoważne:
let otwartyWybieg2 = ((temperaturaPowietrza > 20 && wilgotność < 80 && prędkośćWiatru < 20) || (poziomZagrożenia <= 2 && dostępnyPersonel >= wymaganyPersonel));
console.log(otwartyWybieg); // true
console.log(otwartyWybieg2); // true (ten sam wynik)Przykład 3: Operator warunkowy i przypisanie
// Określenie statusu bezpieczeństwa dla różnych gatunków dinozaurów
let gatunek = "Velociraptor";
let agresywność = 4; // skala 1-5
let wysokośćOgrodzenia = 5; // metry
// Złożone wyrażenie z operatorem warunkowym i przypisaniem
let statusBezpieczeństwa = gatunek === "Tyranozaur" || gatunek === "Spinozaur" || agresywność >= 4 ? "Wysoki" : agresywność >= 3 ? "Średni" : "Niski";
console.log(statusBezpieczeństwa); // "Wysoki" (dla Velociraptora z agresywnością 4)
// Bardziej czytelna wersja z nawiasami pokazująca faktyczną kolejność ewaluacji:
let statusBezpieczeństwa2 = (gatunek === "Tyranozaur" || gatunek === "Spinozaur" || agresywność >= 4) ? "Wysoki" : (agresywność >= 3 ? "Średni" : "Niski");
console.log(statusBezpieczeństwa2); // "Wysoki" (ten sam wynik)Przykład 4: Grupowanie (najwyższy priorytet)
// Obliczanie szacowanej populacji dinozaurów po kilku pokoleniach
let początkowa_populacja = 2;
let wskaźnik_rozrodczości = 3; // średnia liczba potomstwa
let pokolenia = 2;
// Obliczenie bez nawiasów
let szacowana_populacja1 = początkowa_populacja * wskaźnik_rozrodczości ** pokolenia;
console.log(szacowana_populacja1); // 18 (2 * 3² = 2 * 9 = 18)
// Zmiana kolejności za pomocą nawiasów (grupowanie)
let szacowana_populacja2 = (początkowa_populacja * wskaźnik_rozrodczości) ** pokolenia;
console.log(szacowana_populacja2); // 36 ((2 * 3)² = 6² = 36)Przykład 5: Łączenie różnych operatorów
// Kalkulator stanu zapasów po dostawie
let obecneZasoby = 500; // kg
let dostawaTygodniowa = 200; // kg
let średnieZużycieDzienne = 50; // kg
let dniTygodnia = 7;
let czyDziałająLodówki = true;
let maksymalnaZdolnośćMagazynowa = 1000; // kg
// Złożony kalkulator bez wyraźnego grupowania
let nowyStan = obecneZasoby + dostawaTygodniowa - średnieZużycieDzienne * dniTygodnia * (czyDziałająLodówki ? 1 : 1.5);
console.log(nowyStan); // 350 kg (500 + 200 - 50 * 7 * 1)
// Bardziej czytelna wersja z nawiasami pokazująca faktyczną kolejność ewaluacji:
let nowyStan2 = obecneZasoby + dostawaTygodniowa - (średnieZużycieDzienne * dniTygodnia * (czyDziałająLodówki ? 1 : 1.5));
console.log(nowyStan2); // 350 kg (ten sam wynik)
// Sprawdzenie, czy nowy stan nie przekracza pojemności magazynu
let stanProcentowy = nowyStan / maksymalnaZdolnośćMagazynowa * 100;
console.log(stanProcentowy + "%"); // 35%Rekomendacje dotyczące używania nawiasów
Mimo że JavaScript ma ściśle określony priorytet operatorów, używanie nawiasów do jawnego określania kolejności wykonywania operacji ma kilka zalet:
Zwiększa czytelność kodu - nawet jeśli znasz priorytet operatorów, jawne nawiasy czynią kod bardziej czytelnym dla ciebie i innych.
Zapobiega błędom - w złożonych wyrażeniach łatwo popełnić błąd związany z kolejnością wykonywania operacji.
Ułatwia modyfikację - jeśli później zmienisz wyrażenie, nawiasy mogą zapobiec nieoczekiwanym zmianom w logice.
// Przykład używania nawiasów dla zwiększenia czytelności
// Mniej czytelne:
let czyBezpieczny = !ogrodzeniePrzerwane && zasilanieAktywne || trybAwaryjny && ewakuacjaZakończona;
// Bardziej czytelne z nawiasami:
let czyBezpieczny2 = (!ogrodzeniePrzerwane && zasilanieAktywne) || (trybAwaryjny && ewakuacjaZakończona);Łączność (associativity) operatorów
Oprócz priorytetu, ważną cechą operatorów jest ich łączność, która określa kolejność wykonywania operatorów o tym samym priorytecie:
- Łączność od lewej do prawej (left-to-right): większość operatorów, np.
+,-,*,/ - Łączność od prawej do lewej (right-to-left): niektóre operatory, np.
=,**,+=, operatory jednoargumentowe (!,++,--)
// Przykład łączności od lewej do prawej
let a = 5 - 3 - 2; // (5 - 3) - 2 = 0
// Przykład łączności od prawej do lewej
let b = 2;
let c = 3;
let d = 4;
let e = b = c = d; // b = (c = (d)) = 4
console.log(b, c, d, e); // 4, 4, 4, 4
// Potęgowanie jest również łączone od prawej do lewej
let f = 2 ** 3 ** 2; // 2 ** (3 ** 2) = 2 ** 9 = 512
let g = (2 ** 3) ** 2; // 8 ** 2 = 64
console.log(f, g); // 512, 64Praktyczne wskazówki z Parku Jurajskiego
W Parku Jurajskim, niejednoznaczność w protokołach bezpieczeństwa może prowadzić do katastrofalnych skutków. Podobnie, niejednoznaczne wyrażenia w kodzie mogą prowadzić do nieoczekiwanych wyników. Oto kilka wskazówek:
Używaj nawiasów, gdy łączysz różne typy operatorów - szczególnie gdy mieszasz operatory arytmetyczne, logiczne i warunkowe.
Rozbijaj złożone wyrażenia na prostsze - dla większej czytelności i łatwiejszego debugowania, możesz przypisać pośrednie wyniki do zmiennych.
// Zamiast:
let rezultat = a * b + c * d && e > f || g <= h;
// Lepiej:
let część1 = a * b + c * d;
let część2 = e > f;
let część3 = g <= h;
let rezultat = część1 && część2 || część3;- Bądź ostrożny z operatorami postfix i prefix - operatory
++i--mogą prowadzić do nieoczekiwanych wyników, gdy są używane w złożonych wyrażeniach.
let ilośćDinozaurów = 5;
let nowaIlość = ilośćDinozaurów++ * 2; // najpierw użyje wartości 5, potem zwiększy ilośćDinozaurów do 6
console.log(nowaIlość, ilośćDinozaurów); // 10, 6
let ilośćKlatek = 5;
let nowaIlośćKlatek = ++ilośćKlatek * 2; // najpierw zwiększy ilośćKlatek do 6, potem użyje tej wartości
console.log(nowaIlośćKlatek, ilośćKlatek); // 12, 6Podsumowanie
Priorytet operatorów w JavaScript, podobnie jak hierarchia zadań w Parku Jurajskim, określa kolejność wykonywania operacji. Znajomość tej hierarchii jest kluczowa dla pisania poprawnego i przewidywalnego kodu.
Najważniejsze rzeczy do zapamiętania:
- Grupowanie za pomocą nawiasów ma najwyższy priorytet i pozwala kontrolować kolejność wykonywania operacji.
- Operatory arytmetyczne (
*,/) mają wyższy priorytet niż (+,-). - Operatory porównania (
>,<,>=,<=) mają wyższy priorytet niż operatory równości (==,===,!=,!==). - Operator logiczny AND (
&&) ma wyższy priorytet niż OR (||). - Operatory przypisania (
=,+=,-=, itd.) mają jeden z najniższych priorytetów.
Pamiętaj, że w przypadku wątpliwości, zawsze lepiej użyć nawiasów dla jednoznaczności - podobnie jak w Parku Jurajskim, gdzie lepiej jest nadmiarowo zabezpieczyć się przed niespodziewanymi sytuacjami, niż ryzykować nieprzewidziane konsekwencje.
W następnej lekcji przyjrzymy się strukturom kontrolnym - instrukcjom warunkowym, które pozwalają na podejmowanie decyzji w zależności od określonych warunków - niezbędnym do zarządzania tak złożonym przedsięwzięciem jak Park Jurajski.
Kod do tej lekcji: index.js
// Priorytet operatorów w JavaScript
// Kolejność wykonywania operacji
// === Priorytet arytmetyczny ===
console.log("=== Priorytet arytmetyczny ===");
// Mnożenie przed dodawaniem
console.log("2 + 3 * 4 =", 2 + 3 * 4); // 14 (nie 20!)
console.log("(2 + 3) * 4 =", (2 + 3) * 4); // 20 (nawiasy zmieniają kolejność)
// Potęgowanie ma wyższy priorytet niż mnożenie
console.log("2 * 3 ** 2 =", 2 * 3 ** 2); // 18 (nie 36!)
console.log("(2 * 3) ** 2 =", (2 * 3) ** 2); // 36
// === Priorytet logiczny ===
console.log("\n=== Priorytet logiczny ===");
// AND (&&) ma wyższy priorytet niż OR (||)
let a = true, b = false, c = true;
console.log("true || false && false:", true || false && false); // true
// Równoważnie: true || (false && false) -> true || false -> true
console.log("(true || false) && false:", (true || false) && false); // false
// === Porównanie i logika ===
console.log("\n=== Łączenie porównania i logiki ===");
let wiek = 25;
let waga = 7000;
let dieta = "mięsożerca";
// Bez nawiasów - może być mylące
let niebezpieczny = dieta === "mięsożerca" && waga > 5000 || wiek > 30;
console.log("Bez nawiasów:", niebezpieczny);
// Z nawiasami - jasne i czytelne
let niebezpiecznyJasny = (dieta === "mięsożerca" && waga > 5000) || wiek > 30;
console.log("Z nawiasami:", niebezpiecznyJasny);
// === Operator warunkowy (ternary) ===
console.log("\n=== Operator warunkowy ===");
let status = waga > 5000 ? "Duży dinozaur" : "Mały dinozaur";
console.log("Status:", status);
// Twoje zadanie:
// 1. Oblicz wyrażenie z różnymi priorytetami
// 2. Użyj nawiasów aby zmienić kolejność operacji
// 3. Użyj operatora warunkowego (ternary)
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. Który operator logiczny ma wyższy priorytet w JavaScript?
2. Jak wymusić inną kolejność wykonywania operacji niż domyślna w JavaScript?
Zadania praktyczne w grze
- Układanie w pionie
Uporządkuj kategorie operatorów od najwyższego priorytetu do najniższego: