Kurs JavaScript i TypeScript · Moduł 1: Podstawy JavaScript

Priorytet operatorów

9 min czytania ·
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:

  1. Najwyższy priorytet: Sprawdzenie zasilania w ogrodzeniach elektrycznych
  2. Średni priorytet: Sprawdzenie ilości pożywienia dla dinozaurów
  3. 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:

PriorytetKategoriaOperatory
19Grupowanie( ... )
18Dostęp do właściwości i elementy tablicy. [] ?.
17Wywołanie funkcji... ( ... )
16Operatory postfiksowe++ --
15Operatory prefiksowe! ~ + - ++ -- typeof void delete
14Potęgowanie**
13Mnożenie, dzielenie, modulo* / %
12Dodawanie, odejmowanie+ -
11Przesunięcie bitowe<< >> >>>
10Porównania (nierówności)< > <= >= instanceof in
9Równość== != === !==
8Bitowe AND&
7Bitowe XOR^
6Bitowe OR|
5Logiczne AND&&
4Logiczne OR||
3Nullish coalescing??
2Operator warunkowy? :
1Przypisanie= += -= *= /= %= <<= >>= >>>= &= ^= |= **=
0Operator 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:

  1. Zwiększa czytelność kodu - nawet jeśli znasz priorytet operatorów, jawne nawiasy czynią kod bardziej czytelnym dla ciebie i innych.

  2. Zapobiega błędom - w złożonych wyrażeniach łatwo popełnić błąd związany z kolejnością wykonywania operacji.

  3. 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, 64

Praktyczne 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:

  1. Używaj nawiasów, gdy łączysz różne typy operatorów - szczególnie gdy mieszasz operatory arytmetyczne, logiczne i warunkowe.

  2. 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;
  1. 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, 6

Podsumowanie

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:

  1. Grupowanie za pomocą nawiasów ma najwyższy priorytet i pozwala kontrolować kolejność wykonywania operacji.
  2. Operatory arytmetyczne (*, /) mają wyższy priorytet niż (+, -).
  3. Operatory porównania (>, <, >=, <=) mają wyższy priorytet niż operatory równości (==, ===, !=, !==).
  4. Operator logiczny AND (&&) ma wyższy priorytet niż OR (||).
  5. 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. 1. Który operator logiczny ma wyższy priorytet w JavaScript?

  2. 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:

  1. PytaniePriorytet && vs ||
  2. PytanieGrupowanie nawiasami
  3. Ułóż w kolejnościPriorytet operatorów - hierarchia

Przydatne artykuły