ZAWODNIK

JavaScript: zmienne, typy i operatory

INF.03 · teoria
autor: redakcja · 09.09.2026
Deklaracje var, let i const oraz różnica w zasięgu, typy proste i złożone, operator typeof z pułapką typeof null, konwersje napisów na liczby, NaN, operatory arytmetyczne, logiczne i porównania, w tym == kontra ===. Lekcja 11.2 kursu INF.03.

[ INF.03: PYTANIA Z TEGO DZIAŁU ]

Przejrzyj pytania: javascriptĆwicz dział: javascript
Zmien­na to nazwa, pod którą skrypt trzyma jedną war­tość: liczbę, napis, war­tość lo­gicz­ną albo całą ta­bli­cę. Typu nie de­kla­ru­je się z góry, bo JavaScript nadaje go po war­to­ści, która do zmien­nej tra­fi­ła, i zmie­nia w locie przy ko­lej­nym przy­pi­sa­niu. W części pi­sem­nej wra­ca­ją py­ta­nia z ramką kodu („co wy­świe­tli przed­sta­wio­ny skrypt", „jaką war­tość będzie miała zmien­na", „która nazwa zmien­nej jest po­praw­na", „kiedy wy­ni­kiem jest NaN", „czym różni się == od ==="). W za­da­niu prak­tycz­nym liczba wpi­sa­na w for­mu­larz przy­cho­dzi do skryp­tu jako napis, więc bez kon­wer­sji i bez po­rów­nań ta część za­da­nia nie ruszy z miej­sca.

De­kla­ra­cja: var, let i const

De­kla­ra­cja to wpro­wa­dze­nie nazwy zmien­nej do skryp­tu słowem klu­czo­wym. JavaScript ma trzy takie słowa, a różnią się za­się­giem, czyli ob­sza­rem kodu, w którym nazwa jest wi­docz­na, oraz tym, czy wolno przy­pi­sać do niej war­tość po­now­nie.
  • ›
    var (ZMIENNA) to słowo naj­star­sze: zmien­na nim za­de­kla­ro­wa­na jest wi­docz­na w całej funk­cji, klamra nie jest dla niej gra­ni­cą, a nazwę wolno za­de­kla­ro­wać drugi raz. W ar­ku­szach CKE i w ban­kach pytań stoi wszę­dzie, choć nowy kod pisze się bez niej.
  • ›
    let (NIECH) ogra­ni­cza wi­docz­ność do bloku, czyli do klamer z de­kla­ra­cją. War­tość wolno zmie­niać do­wol­nie często.
  • ›
    const (STAŁA) ma ten sam zasięg co let, ale war­tość nadaje się jej raz, przy de­kla­ra­cji. Po­now­ne przy­pi­sa­nie kończy się błędem TypeError.
War­to­ści wy­pi­su­je tu console.log z lekcji o pierw­szym skryp­cie.
1
2
3
4
5
6
7
var jezyk = "JavaScript";
let licznik = 0;
const VAT = 0.23;
licznik = licznik + 1;
console.log(jezyk);
console.log(licznik);
console.log(VAT);
1
2
3
JavaScript
1
0.23
Róż­ni­cę za­się­gu widać do­pie­ro przy de­kla­ra­cji we­wnątrz klamry.
[ JS ]
krok po kroku
skrypt
wierszy: 7
1
2
3
4
5
6
7
od nowa
❮ wstecz
dalej ❯
do końca
krok 0 z 6
start skryptu
ZMIENNE
jeszcze żadnej zmiennej
WYJŚCIE
skrypt jeszcze nic nie wypisał
Otwórz w interpreterze ›
1
2
let zostaje w klamrze
var nie zna klamry
Od­wo­ła­nie do tylkoTutaj spoza klamry kończy się błędem ReferenceError. Zmien­na z var jest za to wi­docz­na już przed swoją de­kla­ra­cją i ma wtedy undefined, więc za­miast czy­tel­ne­go błędu daje ciche undefined w wyniku. Stąd na co dzień: const dla war­to­ści stałej, let dla reszty.
Nazwa zmien­nej za­czy­na się od litery, pod­kre­śle­nia albo dolara, dalej mogą stać cyfry. Spacja, dywiz, znak # i cyfra na po­cząt­ku są nie­do­zwo­lo­ne, a w od­po­wie­dziach eg­za­mi­na­cyj­nych po­praw­na jest zawsze wersja bez pol­skich liter, czyli imie2, a nie imię2. Wiel­kość liter ma zna­cze­nie: cena i Cena to różne zmien­ne. Nazw za­re­zer­wo­wa­nych przez język (let, new, class, if) użyć nie wolno, a nazwy zło­żo­ne za­pi­su­je się z wielką literą na styku słów: cenaBrutto.
Pu­łap­ka: const blo­ku­je po­now­ne przy­pi­sa­nie do nazwy, a nie zmianę za­war­to­ści: ele­men­ty ta­bli­cy za­de­kla­ro­wa­nej jako const wolno pod­mie­niać.

Typy danych i ope­ra­tor typeof

Typ to rodzaj war­to­ści, który de­cy­du­je, co wolno z nią zrobić: liczby się dodaje, napisy skleja, war­to­ści lo­gicz­ne spraw­dza w wa­run­ku. Typów pro­stych jest pięć, a wszyst­ko, co trzyma wiele war­to­ści naraz, jest obiek­tem.
Typ
Co trzyma
Przy­kład de­kla­ra­cji
number
liczby cał­ko­wi­te i ułam­ko­we, jeden wspól­ny typ
let a = 19.99;
string
napis w cu­dzy­sło­wie albo w apo­stro­fach
let b = "Mysz";
boolean
jedną z dwóch war­to­ści: true albo false
let c = true;
undefined
nic, bo zmien­na nie do­sta­ła jesz­cze war­to­ści
let d;
null
celowo wpi­sa­ny brak war­to­ści
let e = null;
object
wiele war­to­ści naraz, w tym ta­bli­cę
let f = [45, 120];
Część ułam­ko­wą od­dzie­la kropka, więc 19,99 jest błędem skład­ni. Liczba cał­ko­wi­ta i ułam­ko­wa to ten sam typ number, choć od­po­wie­dzi w ar­ku­szach na­zy­wa­ją je osobno: „licz­bo­wy, cał­ko­wi­ty" i „zmien­no­prze­cin­ko­wy". Napis wolno za­pi­sać w cu­dzy­sło­wie albo w apo­stro­fach i obie po­sta­cie znaczą to samo, ina­czej niż przy zmien­nych i ope­ra­to­rach w PHP. Ta­bli­ca­mi i obiek­ta­mi zaj­mu­je się osobna lekcja.
typeof (JAKIEGO TYPU) to ope­ra­tor zwra­ca­ją­cy nazwę typu jako napis.
1
2
3
4
5
6
7
8
const cena = 19.99;
const nazwa = "Mysz";
const dostepny = true;
let rabat;
console.log(typeof cena);
console.log(typeof nazwa);
console.log(typeof dostepny);
console.log(typeof rabat);
1
2
3
4
number
string
boolean
undefined
War­tość undefined nadaje sam język zmien­nej, która nic nie do­sta­ła, a null wpi­su­je pro­gra­mi­sta. Trzy wyniki typeof trzeba znać na pamięć.
1
2
3
console.log(typeof null);
console.log(typeof [1, 2, 3]);
console.log(typeof NaN);
1
2
3
object
object
number
typeof null daje object, choć null żadnym obiek­tem nie jest: to błąd z pierw­szej wersji języka, zo­sta­wio­ny dla zgod­no­ści ze sta­ry­mi stro­na­mi. Ta­bli­ca jest od­mia­ną obiek­tu, a NaN, czyli wynik nie­uda­ne­go dzia­ła­nia na licz­bach, ma typ number.

Kon­wer­sje: kiedy napis staje się liczbą

Kon­wer­sja to za­mia­na war­to­ści na inny typ. JavaScript robi ją sam, bez py­ta­nia, a wynik zależy od tego, który ope­ra­tor dostał napis.
1
2
3
4
console.log("5" + 3);
console.log("5" - 3);
console.log("5" * "2");
console.log(3 + 4 + "5");
1
2
3
4
53
2
10
75
Ope­ra­tor + ma dwa za­da­nia: dodaje liczby i skleja napisy. Gdy po któ­rej­kol­wiek stro­nie stoi napis, wy­gry­wa skle­ja­nie, więc "5" + 3 daje 53. Po­zo­sta­łe ope­ra­to­ry aryt­me­tycz­ne skle­jać nie po­tra­fią, więc za­mie­nia­ją napis na liczbę i "5" - 3 daje 2. W ostat­nim wier­szu 3 + 4 po­li­czy­ło się jako liczby, bo napis po­ja­wił się do­pie­ro póź­niej.
Kon­wer­sję lepiej wy­ko­nać samemu, jedną z czte­rech funk­cji.
Zapis
Wynik
Kiedy
Number("12")
12
cały napis musi być liczbą
Number("12abc")
NaN
jeden znak spoza liczby psuje całość
Number("")
0
pusty napis staje się zerem
parseInt("12abc")
12
czyta od po­cząt­ku do pierw­sze­go nie­pa­su­ją­ce­go znaku
parseInt("3.9")
3
ucina część ułam­ko­wą, nie za­okrą­gla
parseFloat("3.9 kg")
3.9
za­cho­wu­je część ułam­ko­wą
String(12)
"12"
liczba jako napis
1
2
3
4
5
const wpisane = "3.9 kg";
console.log(parseInt(wpisane));
console.log(parseFloat(wpisane));
console.log(parseInt(3 / 2));
console.log(Number(wpisane));
1
2
3
4
3
3.9
1
NaN
NaN (NIE LICZBA) to war­tość, którą JavaScript oddaje, gdy dzia­ła­nie aryt­me­tycz­ne nie miało z czego po­li­czyć wyniku, naj­czę­ściej dla­te­go, że w zmien­nej był napis. NaN nie jest równe ni­cze­mu, także samemu sobie, więc spraw­dza się je funk­cją isNaN (CZY NIE LICZBA).
1
2
3
4
5
const ilosc = Number("dwa");
console.log(ilosc);
console.log(NaN === NaN);
console.log(isNaN(ilosc));
console.log(isNaN("12"));
1
2
3
4
NaN
false
true
false
W wa­li­da­cji ważny jest ostat­ni wiersz: isNaN("12") daje false, bo napis z samych cyfr da się za­mie­nić na liczbę, i do­pie­ro litera w polu zwraca true.
Pu­łap­ka: parseInt czyta napis od po­cząt­ku i oddaje to, co zdążył prze­czy­tać, a Number wymaga, żeby liczbą był CAŁY napis. Dla­te­go parseInt("12abc") daje 12, a Number("12abc") daje NaN.

Ope­ra­to­ry aryt­me­tycz­ne, przy­pi­sa­nia i in­kre­men­ta­cja

Ope­ra­tor to znak albo para znaków wy­ko­nu­ją­cych dzia­ła­nie na jednej lub dwóch war­to­ściach.
Ope­ra­tor
Znaczy
Przy­kład
Wynik
+
do­da­wa­nie liczb, skle­ja­nie na­pi­sów
7 + 3
10
-
odej­mo­wa­nie
7 - 3
4
*
mno­że­nie
7 * 3
21
/
dzie­le­nie, wynik bywa ułam­kiem
10 / 4
2.5
%
reszta z dzie­le­nia
7 % 3
1
**
po­tę­go­wa­nie
2 ** 3
8
Dzie­le­nie zawsze zwraca wynik do­kład­ny, więc 10 / 4 daje 2.5, a nie 2, a sam iloraz cał­ko­wi­ty wy­cią­ga do­pie­ro parseInt(10 / 4) albo Math.floor(10 / 4). Ope­ra­tor % liczy resztę, więc liczba % 2 === 0 to test pa­rzy­sto­ści. Potęgę za­pi­su­je się dwiema gwiazd­ka­mi albo star­szym Math.pow, i obie po­sta­cie dają ten sam wynik.
1
2
3
4
console.log(10 / 4);
console.log(7 % 3);
console.log(2 ** 3);
console.log(Math.pow(2, 3));
1
2
3
4
2.5
1
8
8
Przy­pi­sa­nie zło­żo­ne skraca zapis, w którym zmien­na zmie­nia własną war­tość: suma += 5 znaczy suma = suma + 5, tak samo -=, *=, /= i %=.
1
2
3
4
5
let suma = 10;
suma += 5;
suma *= 2;
suma %= 7;
console.log(suma);
Wynik: 2. Ko­lej­no 15, potem 30, a reszta z dzie­le­nia 30 przez 7 to 2.
++ (in­kre­men­ta­cja) zwięk­sza zmien­ną o jeden, -- (de­kre­men­ta­cja) zmniej­sza. W osob­nym wier­szu obie po­sta­cie znaczą to samo co a = a + 1, ale w wy­ra­że­niu de­cy­du­je miej­sce znaku: przed nazwą naj­pierw zmie­nia zmien­ną i oddaje nową war­tość, po nazwie oddaje war­tość STARĄ i zmie­nia zmien­ną potem.
1
2
3
4
5
6
let a = 5;
const b = a++;
const c = ++a;
console.log(a);
console.log(b);
console.log(c);
1
2
3
7
5
7
a++ oddaje do b piątkę i usta­wia a na 6, a ++a pod­no­si a do 7 i do­pie­ro tę sió­dem­kę wpi­su­je do c.

Po­rów­na­nia, ope­ra­to­ry lo­gicz­ne i wybór jednej z dwóch war­to­ści

Po­rów­na­nie to ope­ra­tor, który z dwóch war­to­ści robi true albo false.
Ope­ra­tor
Znaczy
Przy­kład
Wynik
==
równe po kon­wer­sji, bez pa­trze­nia na typ
1 == "1"
true
===
równe co do war­to­ści I typu
1 === "1"
false
!=
różne po kon­wer­sji
1 != "1"
false
!==
różne co do war­to­ści albo typu
1 !== "1"
true
>
więk­sze, napisy po­rów­ny­wa­ne znak po znaku
"def" > "abc"
true
>=
więk­sze albo równe
5 >= 5
true
[ JS ]
krok po kroku
skrypt
wierszy: 4
1
2
3
4
5
6
od nowa
❮ wstecz
dalej ❯
do końca
krok 0 z 4
start skryptu
ZMIENNE
jeszcze żadnej zmiennej
WYJŚCIE
skrypt jeszcze nic nie wypisał
Otwórz w interpreterze ›
1
2
3
4
true
false
true
false
== spro­wa­dza obie strony do wspól­ne­go typu i do­pie­ro potem po­rów­nu­je, dla­te­go napis "1" zrów­nał się z liczbą 1, a zero z war­to­ścią false. === za­czy­na od typu: gdy typy są różne, od razu zwraca false. We wła­snym kodzie używa się ===, ale == trzeba roz­po­znać, bo stoi w więk­szo­ści pytań. Napisy po­rów­nu­ją się znak po znaku według kodów znaków, więc "def" > "abc" daje true, a "10" < "9" rów­nież, bo de­cy­du­je pierw­szy znak.
Wa­ru­nek zło­żo­ny łączy kilka po­rów­nań ope­ra­to­ra­mi lo­gicz­ny­mi: && (I) wymaga obu części, || (LUB) wy­star­czy jedna, ! (NIE) od­wra­ca wynik. Ope­ra­tor && wiąże moc­niej niż ||, więc grupy zamyka się w na­wia­sach.
1
2
3
4
5
const kolor = "zielony";
const pojemnosc = 2;
const promocja = (kolor === "niebieski" || kolor === "zielony") && pojemnosc === 2;
console.log(promocja);
console.log(!promocja);
1
2
true
false
Wa­ru­nek na prze­dział od 0 do 100 to a > 0 && a < 100. Ta sama para po­rów­nań z || jest praw­dzi­wa dla każdej liczby, bo do­wol­na liczba jest albo więk­sza od zera, albo mniej­sza od stu. In­struk­cje wa­run­ko­we i pętle opi­su­je osobna lekcja.
Fał­szem jest sześć war­to­ści: false, 0, pusty napis, null, undefined i NaN. Wszyst­ko inne jest prawdą, także napis "0" i liczba ujemna.
Ope­ra­tor trój­ar­gu­men­to­wy skraca wybór jednej z dwóch war­to­ści do jed­ne­go wier­sza: wa­ru­nek, znak za­py­ta­nia, war­tość dla prawdy, dwu­kro­pek, war­tość dla fałszu.
1
2
3
const stan = 0;
const opis = stan > 0 ? "dostępny" : "brak w magazynie";
console.log(opis);
Wynik: brak w magazynie.
Pu­łap­ka: = przy­pi­su­je, == po­rów­nu­je war­to­ści, === war­tość razem z typem. Wa­ru­nek if (x = 5) ni­cze­go nie po­rów­nu­je: wpi­su­je do x piątkę i zawsze jest praw­dzi­wy.

Łą­cze­nie na­pi­sów i sza­blo­ny

Napisy skleja ten sam ope­ra­tor +, który dodaje liczby, więc "Cena: " + 120 daje Cena: 120, bo liczba zo­sta­je za­mie­nio­na na napis. Sza­blon to napis w od­wrot­nych apo­stro­fach, w którym war­tość zmien­nej wsta­wia się za­pi­sem ${nazwa}: nie trzeba wtedy za­my­kać i otwie­rać cu­dzy­sło­wu przy każdej zmien­nej.
1
2
3
4
5
6
const nazwa = "Mysz";
const cena = 49;
console.log("Produkt: " + nazwa + ", cena " + cena + " zł");
console.log(`Produkt: ${nazwa}, cena ${cena} zł`);
console.log("Suma: " + (2 + 3));
console.log("Suma: " + 2 + 3);
1
2
3
4
Produkt: Mysz, cena 49 zł
Produkt: Mysz, cena 49 zł
Suma: 5
Suma: 23
Dwa ostat­nie wier­sze różni jeden nawias. Bez niego dzia­ła­nia idą od lewej: do napisu do­kle­ja się naj­pierw dwójka, potem trójka, więc za­miast sumy po­wsta­je 23.

Na eg­za­mi­nie

Py­ta­nia pi­sem­ne o zmien­ne i ope­ra­to­ry mają kilka sta­łych kształ­tów. Ramka z kodem i py­ta­nie, co wy­pi­sze skrypt albo jaką war­tość ma zmien­na na końcu: liczy się wiersz po wier­szu, za­pi­su­jąc wynik każ­de­go przy­pi­sa­nia, a przy ++ pil­nu­je, czy znak stoi przed nazwą, czy po niej. Ten sam ra­chu­nek można przejść w prze­glą­dar­ce w in­ter­pre­te­rze JavaScript. Py­ta­nie o typ: var x = true; daje typ lo­gicz­ny, a typ zmien­nej po­wsta­je przez przy­pi­sa­nie war­to­ści, nie przez de­kla­ra­cję. Py­ta­nie o nazwę: po­praw­na jest imie2, od­pa­da­ją nazwy z krzy­ży­kiem, z pol­skim zna­kiem i ze zna­kiem pro­cen­ta. Py­ta­nie o grupę ope­ra­to­rów: && oraz || są lo­gicz­ne, nie bitowe i nie przy­pi­sa­nia. Py­ta­nie o rów­no­waż­ność za­pi­sów: zmienna++ znaczy to samo co zmienna += 1, a zmienna -= 1 to samo co zmienna--.
Kilka od­po­wie­dzi myli się re­gu­lar­nie. parseInt(3 / 2) daje 1, bo ucina część ułam­ko­wą, pod­czas gdy 3 / 2, Number(3 / 2) i parseFloat(3 / 2) dają 1.5. Wy­ni­kiem jest NaN wtedy, gdy dzia­ła­nie aryt­me­tycz­ne do­sta­ło napis, a nie wtedy, gdy liczby były ujemne albo ułam­ko­we. Błąd lo­gicz­ny w ramce, po którym skrypt nic nie wy­pi­su­je, to zwykle = za­miast == w in­struk­cji if. Ope­ra­tor % daje resztę, nie iloraz, więc pa­rzy­stość spraw­dza liczba % 2 === 0.
W za­da­niu prak­tycz­nym zmien­ne trzy­ma­ją war­tość po­bra­ną z pola for­mu­la­rza, wynik ob­li­cze­nia i tekst ko­mu­ni­ka­tu. War­tość z pola jest na­pi­sem, także z pola type="number", więc do­da­nie jej wprost sklei dwie liczby za­miast je zsu­mo­wać: naj­pierw idzie Number albo parseInt, potem spraw­dze­nie isNaN, a na końcu ra­chu­nek i po­rów­na­nia z ===. Gotowy ko­mu­ni­kat składa się sza­blo­nem i trafia do wska­za­ne­go ele­men­tu przez innerHTML, przy czym wsta­wia­nie tam tekstu wpi­sa­ne­go przez użyt­kow­ni­ka bez spraw­dze­nia otwie­ra drogę do wy­ko­na­nia obcego kodu. Po­bie­ra­nie ele­men­tów opi­su­je lekcja o modelu DOM, a odbiór danych z pól lekcja o zda­rze­niach i for­mu­la­rzach.

Ściąga

Zapis
Znaczy
let licznik = 0;
zmien­na o za­się­gu bloku, war­tość wolno zmie­niać
const VAT = 0.23;
war­tość nadana raz, po­now­ne przy­pi­sa­nie to błąd
var x = true;
star­sze słowo, zasięg całej funk­cji, typ lo­gicz­ny
typeof 19.99
number, bo liczby są jednym typem
typeof null
object, mimo że null obiek­tem nie jest
"5" + 3
53, plus przy na­pi­sie skleja
"5" - 3
2, minus za­mie­nia napis na liczbę
Number("12abc")
NaN, bo cały napis musi być liczbą
parseInt("12abc")
12, czyta do pierw­sze­go nie­pa­su­ją­ce­go znaku
parseFloat("3.9 kg")
3.9, z czę­ścią ułam­ko­wą
isNaN(x)
true, gdy war­to­ści nie da się uznać za liczbę
7 % 3
1, reszta z dzie­le­nia
2 ** 3
8, to samo co Math.pow(2, 3)
a++
oddaje starą war­tość, potem zwięk­sza o jeden
1 == "1"
true, po­rów­na­nie po kon­wer­sji
1 === "1"
false, bo typy są różne
Pobierz ściągę PDF

[ W TYM DZIALE ]

poprzednia: JavaScript: pierwszy skrypt na stronienastępna: JavaScript: instrukcje warunkowe i pętlespis działu: JavaScript

[ INF.03: INNE ARTYKUŁY ]

Hub INF.03Zakres materiałuBazy danych i SQL na egzaminie INF.03CSS na egzaminie INF.03Formularze HTML na egzaminie INF.03Grafika i multimedia na egzaminie INF.03HTML na egzaminie INF.03pokaż więcej (47)
ZAWODNIK
egzamin zawodowy INF.02 · INF.03 · INF.04
Serwer Discord›
Egzaminy zawodowe IT/Matury/Studia
@yastor
Polityka prywatnościRegulamin
© 2026 Zawodnik · by Yastor
Arkusze i zasady oceniania pochodzą z CKE. Serwis nie jest powiązany z Centralną Komisją Egzaminacyjną.