Kurs JavaScript i TypeScript · Moduł 1: Podstawy JavaScript
Operatory arytmetyczne i przypisania
W tej lekcji9
Poranna odprawa w centrum kontroli Parku Jurajskiego zaczyna się od liczb. Ile mięsa wydać raptorom? Ile jaj nie zmieści się w inkubatorach? Ilu zwiedzających przeszło przez bramę? Dr. Rex zleca te obliczenia systemom parku, a JavaScript daje im dwie rodziny narzędzi: operatory arytmetyczne, które liczą, oraz operatory przypisania, które zapisują wynik w zmiennej.
Cztery podstawowe działania
Dodawanie, odejmowanie, mnożenie i dzielenie zapisujesz znakami +, -, * oraz /, a JavaScript liczy jak kalkulator w laboratorium:
// Dodawanie (+)
let iloscRaptorów = 5;
let noweWyklute = 3;
let całkowitaIloscRaptorów = iloscRaptorów + noweWyklute; // 8
// Odejmowanie (-)
let dinozauryOgółem = 57;
let przeniesioneDinozaury = 12;
let pozostałeDinozaury = dinozauryOgółem - przeniesioneDinozaury; // 45
// Mnożenie (*)
let dzienneZapotrzebowanieNaPokarm = 20; // kg na dinozaura
let iloscTroodontów = 7;
let całkowiteZapotrzebowanie = dzienneZapotrzebowanieNaPokarm * iloscTroodontów; // 140 kg
// Dzielenie (/)
let zapasyMięsa = 1500; // kg
let dzienneZużycie = 300; // kg
let wystarczyNaDni = zapasyMięsa / dzienneZużycie; // 5 dniZwróć uwagę, czego te działania nie robią: iloscRaptorów i dinozauryOgółem zachowują swoje wartości, a wynik trafia do nowej zmiennej. Dzielenie nie obcina też ułamków: 7 / 2 daje 3.5, bo liczby całkowite i ułamkowe to w JavaScript jeden typ number.
Reszta z dzielenia i potęgowanie
Operator % zwraca resztę z dzielenia: 17 jaj po 4 na inkubator to cztery pełne inkubatory i jedno jajo w kolejce. Operator ** podnosi liczbę do potęgi:
// Reszta z dzielenia (%)
let liczbaJaj = 17;
let pojemnośćInkubatora = 4;
let jajaPozostałePoZapełnieniuInkubatorów = liczbaJaj % pojemnośćInkubatora; // 1
// Potęgowanie (**)
let początkowaPopulacja = 2;
let lataRozrodu = 3;
let szacowanaPopulacja = początkowaPopulacja ** lataRozrodu; // 2^3 = 8Mimo znaku % ten operator nie ma nic wspólnego z procentami: 10 % 3 to 1, bo 10 = 3 · 3 + 1. Z kolei 2 ** 3 oznacza 2 · 2 · 2, czyli 8, a nie 6 ani 9.
Inkrementacja i dekrementacja
Liczniki często zmieniają się o jeden: wchodzi zwiedzający, alarm spada o poziom. Na taką okazję JavaScript ma skróty ++ i --:
// Inkrementacja (++) - zwiększenie o 1
let odwiedzającyPark = 120;
odwiedzającyPark++; // teraz odwiedzającyPark = 121
// Dekrementacja (--) - zmniejszenie o 1
let poziomZagrożenia = 5;
poziomZagrożenia--; // teraz poziomZagrożenia = 4W przeciwieństwie do + i - te operatory zmieniają samą zmienną, więc na stałej const kończą się błędem TypeError. Mają też dwie formy, które różnią się wartością zwracaną w chwili użycia:
let a = 5;
console.log(++a); // 6 - najpierw zwiększa, potem zwraca
let b = 5;
console.log(b++); // 5 - najpierw zwraca starą wartość, potem zwiększa
console.log(b); // 6Obie zmienne kończą z wartością 6, różni się tylko to, co trafia do console.log w tej samej linii. Moja rada: pisz ++ w osobnej linii, a nie w środku większego wyrażenia.
Kolejność działań
Dr. Rex liczy dzienne zapotrzebowanie mięsożerców: pięć małych drapieżników zjada po 50 kg, trzy duże po 300 kg. Oto próba stażysty i poprawka:
let małeMięsożerne = 5;
let dużeMięsożerne = 3;
let dzienneSpożycieMałych = 50; // kg
let dzienneSpożycieDużych = 300; // kg
// Nieprawidłowe obliczenie - zapomniany składnik
let nieprawidłoweZużycie = małeMięsożerne + dużeMięsożerne * dzienneSpożycieDużych;
console.log(nieprawidłoweZużycie); // 905 (nieprawidłowy wynik!)
// Prawidłowe obliczenie (z nawiasami)
let prawidłoweZużycie = (małeMięsożerne * dzienneSpożycieMałych) + (dużeMięsożerne * dzienneSpożycieDużych);
console.log(prawidłoweZużycie); // 1150 kg (prawidłowy wynik)
// Tu nawiasy naprawdę zmieniają wynik
console.log((małeMięsożerne + dużeMięsożerne) * dzienneSpożycieDużych); // 2400Skąd 905? Mnożenie ma pierwszeństwo, więc JavaScript liczy 3 * 300 i dodaje 5, czyli samą liczbę zwierząt. Błąd tkwi we wzorze, a nie w kolejności. W poprawnej wersji nawiasy służą czytelności, bo bez nich wynik też wyniósłby 1150. Wynik zmieniają dopiero w ostatniej linii, gdzie każą najpierw dodać osobniki.
Standardowa kolejność działań (PEMDAS):
- Nawiasy -
( ) - Potęgi -
** - Mnożenie i dzielenie -
*/ - Dodawanie i odejmowanie -
+-
Skrót pochodzi od angielskich nazw poziomów: Parentheses, Exponents, Multiplication/Division, Addition/Subtraction. Operator % stoi na poziomie * i /, a działania z jednego poziomu idą od lewej do prawej. Wyjątkiem jest potęgowanie, liczone od prawej: 2 ** 3 ** 2 to 512. Pełną tabelę poznasz w lekcji o priorytecie operatorów.
Operatory przypisania
Liczników zwykle nie ustawia się od nowa, tylko aktualizuje. Zamiast pisać zwiedzający = zwiedzający + 50, możesz połączyć działanie z przypisaniem w jednym operatorze:
// Podstawowe przypisanie (=)
let liczbaTRexów = 2;
// Przypisanie z dodawaniem (+=)
let zwiedzający = 100;
zwiedzający += 50; // równoważne zwiedzający = zwiedzający + 50; (teraz 150)
// Przypisanie z odejmowaniem (-=)
let zasobyPaliwa = 1000;
zasobyPaliwa -= 250; // równoważne zasobyPaliwa = zasobyPaliwa - 250; (teraz 750)Zapis count += 5 znaczy dokładnie to samo co count = count + 5: odczytaj wartość, dodaj 5 i zapisz wynik w tej samej zmiennej. Tak samo działają pozostałe operatory:
// Przypisanie z mnożeniem (*=)
let populacjaDilofozaurów = 4;
populacjaDilofozaurów *= 2; // równoważne populacjaDilofozaurów = populacjaDilofozaurów * 2; (teraz 8)
// Przypisanie z dzieleniem (/=)
let racjaPokarmowa = 1200;
racjaPokarmowa /= 4; // równoważne racjaPokarmowa = racjaPokarmowa / 4; (teraz 300)
// Przypisanie z resztą z dzielenia (%=)
let miejscaWJeepach = 20;
miejscaWJeepach %= 6; // równoważne miejscaWJeepach = miejscaWJeepach % 6; (teraz 2)
// Przypisanie z potęgowaniem (**=)
let wzrostPopulacji = 2;
wzrostPopulacji **= 3; // równoważne wzrostPopulacji = wzrostPopulacji ** 3; (teraz 8)Operator złożony nadpisuje zmienną, więc tak jak ++ nie zadziała na stałej const. Polecam go zamiast pełnego zapisu: nazwa zmiennej pojawia się raz, więc nie zrobisz literówki, przepisując ją drugi raz.
Łączenie operatorów w praktyce
Prawdziwe zadania łączą kilka operatorów. Po wykluciu się pięciu młodych trzeba zaktualizować pokoje w wylęgarni, policzyć zapełnienie i sprawdzić, czy wystarczy opiekunów (jeden na trzy dinozaury):
// Scenariusz: Aktualizacja zasobów parku po wykluciu się nowych dinozaurów
let dostępnePokoje = 50;
let zajętePokoje = 30;
let noweDinozaury = 5;
let personelOpiekuńczy = 15;
// Aktualizacja pokoi: nowe dinozaury zajmują wolne miejsca
dostępnePokoje -= noweDinozaury; // 45
zajętePokoje += noweDinozaury; // 35
// Obliczenie nowego poziomu zapełnienia (w procentach)
let poziomZapełnienia = zajętePokoje / (zajętePokoje + dostępnePokoje) * 100;
console.log(`Poziom zapełnienia parku: ${poziomZapełnienia}%`); // 43.75%
// Obliczenie potrzebnego personelu (1 opiekun na 3 dinozaury)
let wymaganyPersonel = Math.ceil(zajętePokoje / 3); // 12
let dodatkowyPersonel = wymaganyPersonel - personelOpiekuńczy;
if (dodatkowyPersonel > 0) {
console.log(`Potrzebujemy zatrudnić ${dodatkowyPersonel} dodatkowych opiekunów.`);
} else {
console.log("Mamy wystarczającą liczbę personelu.");
}Aktualizujemy obie zmienne, bo młode zajmują wolne pokoje, a ich suma zostaje bez zmian: 80. Math.ceil zaokrągla w górę, bo nie da się zatrudnić dwóch trzecich opiekuna: 35 / 3 daje 12 osób. Mamy 15, więc program wypisze drugi komunikat. Napis w grawisach z ${...} to template literal, a if wybiera jedną z dwóch ścieżek. Oba narzędzia omówimy w kolejnych lekcjach.
Uwaga na tekst
Operator + ma podwójną naturę: gdy choć jedna strona jest tekstem, skleja napisy zamiast dodawać. To konkatenacja z lekcji o konwersji typów:
// Uwaga na operacje na stringach!
let raport = "Raport #";
let numerRaportu = 42;
let pełnyRaport = raport + numerRaportu; // "Raport #42" (konkatenacja stringów)
// Różnica między numerycznymi operacjami a konkatenacją stringów
let wynik1 = 5 + 10; // 15 (liczba)
let wynik2 = "5" + "10"; // "510" (string)
let wynik3 = "5" + 10; // "510" (string, 10 zostało skonwertowane na string)
let wynik4 = 5 + "10"; // "510" (string, 5 zostało skonwertowane na string)Pozostałe operatory arytmetyczne zamieniają tekst na liczbę, więc "5" - 2 daje 3. Dlatego dane z formularza zamieniaj przez Number(), zanim dodasz je do licznika.
Podsumowanie
Operatory arytmetyczne i przypisania są fundamentem bardziej złożonych operacji. Pozwalają na:
- wykonywanie działań matematycznych (
+,-,*,/,%,**), - inkrementację i dekrementację wartości (
++,--), - zwięzłe aktualizowanie zmiennych (
+=,-=,*=,/=,%=,**=).
Pilnuj kolejności działań i typów danych: pomyłka w obliczeniach bywa groźna w parku pełnym drapieżników. W następnej lekcji poznasz operatory porównania i logiczne, dzięki którym systemy parku podejmują decyzje.
Praktyka
W piaskownicy czeka konsola centrum kontroli: sumy populacji, 10 % 3, 2 ** 10, porównanie ++a z b++ i aktualizacje zapasów. Zmieniaj liczby i przewiduj każdy wynik, zanim pojawi się w konsoli. Na końcu czekają dwa zadania do samodzielnego rozwiązania.
Kod do tej lekcji: index.js
// Operatory arytmetyczne i przypisania
// Obliczenia w systemie zarządzania Parkiem Jurajskim
// === Operatory arytmetyczne ===
console.log("=== Operatory arytmetyczne ===");
let raptory = 8;
let triceratopsy = 12;
// Dodawanie, odejmowanie, mnożenie, dzielenie
console.log("Suma:", raptory + triceratopsy); // 20
console.log("Różnica:", triceratopsy - raptory); // 4
console.log("Iloczyn:", raptory * 3); // 24
console.log("Iloraz:", triceratopsy / 4); // 3
// Reszta z dzielenia (modulo)
console.log("Reszta 10 % 3:", 10 % 3); // 1
// Potęgowanie
console.log("2 ** 10:", 2 ** 10); // 1024
// === Inkrementacja i dekrementacja ===
console.log("\n=== Inkrementacja / Dekrementacja ===");
let populacja = 50;
populacja++; // 51
console.log("Po ++:", populacja);
populacja--; // 50
console.log("Po --:", populacja);
// Różnica pre vs post
let a = 5;
console.log("++a:", ++a); // 6 (najpierw zwiększa, potem zwraca)
let b = 5;
console.log("b++:", b++); // 5 (najpierw zwraca, potem zwiększa)
console.log("b po b++:", b); // 6
// === Operatory przypisania ===
console.log("\n=== Operatory przypisania ===");
let zapasy = 1000;
zapasy += 200; // zapasy = zapasy + 200
console.log("Po += 200:", zapasy);
zapasy -= 150; // zapasy = zapasy - 150
console.log("Po -= 150:", zapasy);
zapasy *= 2; // zapasy = zapasy * 2
console.log("Po *= 2:", zapasy);
zapasy /= 4; // zapasy = zapasy / 4
console.log("Po /= 4:", zapasy);
// Twoje zadanie:
// 1. Oblicz całkowite zapotrzebowanie na pokarm (dinozaury * kg/dzień)
// 2. Użyj operatorów przypisania do aktualizacji stanu zasobów
Zapamiętaj: operator arytmetyczny tylko liczy, a operator przypisania zapisuje wynik, jak laborant, który najpierw waży porcję, a potem wpisuje ją do dziennika karmień.
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. Jaki jest wynik wyrażenia 10 % 3 w JavaScript?
2. Co zwróci wyrażenie 2 ** 3 w JavaScript?
3. Co jest równoważne zapisowi: count += 5?
Zadania praktyczne w grze
- Układanie w pionie
Uporządkuj operatory arytmetyczne od najwyższego priorytetu do najniższego: