Node.js dla początkujących - Część 2: Operatory i wyrażenia

Operatory i Wyrażenia w JavaScript – Kurs dla Początkujących

W poprzedniej części kursu, omawiając zmienne, wspomnieliśmy o podstawowych operatorach. Dziś przyjrzymy się im znacznie dokładniej i poznamy ich pełen zakres. Operatory to symbole, które wykonują operacje na wartościach (zwanych operandami). Połączenie operatorów i operandów tworzy wyrażenia.

Operatory Arytmetyczne

Służą do wykonywania podstawowych działań matematycznych:

• + (dodawanie): 5 + 3 daje 8
• - (odejmowanie): 10 - 4 daje 6
• * (mnożenie): 6 * 7 daje 42
• / (dzielenie): 15 / 3 daje 5
• % (modulo – reszta z dzielenia): 10 % 3 daje 1 (bo 10 = 3 * 3 + 1)
• ** (potęgowanie): 2 ** 3 daje 8 (2 do potęgi 3)

Przykłady:

let x = 10;
let y = 3;

console.log(x + y); // 13
console.log(x - y); // 7
console.log(x * y); // 30
console.log(x / y); // 3.333...
console.log(x % y); // 1
console.log(x ** y); // 1000

Operatory Porównania

Porównują dwie wartości i zwracają wartość logiczną (true – prawda lub false – fałsz):

• == (równy): 5 == 5 daje true, 5 == "5" daje true (sprawdza tylko wartość, nie typ)
• === (ściśle równy): 5 === 5 daje true, 5 === "5" daje false (sprawdza wartość i typ)
• != (różny): 5 != 6 daje true
• !== (ściśle różny): 5 !== "5" daje true
• > (większy niż): 8 > 3 daje true
• < (mniejszy niż): 2 < 7 daje true
• >= (większy lub równy): 4 >= 4 daje true
• <= (mniejszy lub równy): 1 <= 5 daje true

Przykłady:

let a = 10;
let b = "10";

console.log(a == b); // true
console.log(a === b); // false
console.log(a != b); // false
console.log(a !== b); // true

Operatory Logiczne

Służą do łączenia wyrażeń logicznych:

• && (AND – i): (5 > 3) && (2 < 4) daje true (oba warunki muszą być prawdziwe)
• || (OR – lub): (5 < 3) || (2 < 4) daje true (przynajmniej jeden warunek musi być prawdziwy)
• ! (NOT – negacja): !(5 == 5) daje false (odwraca wartość logiczną)

Przykłady:

let prawda = true;
let falsz = false;

console.log(prawda && falsz); // false
console.log(prawda || falsz); // true
console.log(!prawda); // false

Operatory Przypisania

Służą do przypisywania wartości zmiennym:

• = (przypisanie): x = 5 przypisuje wartość 5 do zmiennej x
• += (dodawanie i przypisanie): x += 3 to to samo co x = x + 3
• -= (odejmowanie i przypisanie): x -= 2 to to samo co x = x - 2
• *= (mnożenie i przypisanie): x *= 4 to to samo co x = x * 4
• /= (dzielenie i przypisanie): x /= 2 to to samo co x = x / 2
• %= (modulo i przypisanie): x %= 3 to to samo co x = x % 3

Przykłady:

let liczba = 10;
liczba += 5; // liczba teraz ma wartość 15
console.log(liczba); // 15

Operatory Bitowe

Operatory bitowe operują na bitach liczb całkowitych. W JavaScript liczby są reprezentowane jako 32-bitowe liczby ze znakiem. Operatory te rzadziej są używane w codziennym programowaniu webowym, ale są przydatne w optymalizacji, operacjach niskopoziomowych (np. praca z grafiką, protokołami sieciowymi) i algorytmach.

• & (AND bitowe): Zwraca 1 tylko wtedy, gdy oba odpowiadające sobie bity operandów są równe 1.
• | (OR bitowe): Zwraca 1, gdy co najmniej jeden z odpowiadających sobie bitów operandów jest równy 1.
• ^ (XOR bitowe – exclusive OR): Zwraca 1, gdy odpowiadające sobie bity operandów są różne.
• ~ (NOT bitowe – negacja): Odwraca wszystkie bity operandu (0 staje się 1, a 1 staje się 0).
• << (przesunięcie bitowe w lewo): Przesuwa bity operandu w lewo o określoną liczbę pozycji. Wprowadza zera od prawej strony. Odpowiada mnożeniu przez potęgę 2.
• >> (przesunięcie bitowe w prawo): Przesuwa bity operandu w prawo o określoną liczbę pozycji. Zachowuje bit znaku (jeśli liczba była ujemna, z lewej strony wstawiane są jedynki). Odpowiada dzieleniu całkowitemu przez potęgę 2.
• >>> (bez znakowe przesunięcie bitowe w prawo): Przesuwa bity operandu w prawo o określoną liczbę pozycji. Zawsze wstawia zera z lewej strony, niezależnie od znaku liczby.

Przykłady Operatorów Bitowych:

Aby lepiej zrozumieć działanie operatorów bitowych, spójrzmy na przykłady z reprezentacją binarną liczb:

let a = 5; // Binarnie: 0101
let b = 3; // Binarnie: 0011

// AND bitowe (&)
console.log(a & b); // 1 (Binarnie: 0001)
// 0101
// 0011
// ----
// 0001

// OR bitowe (|)
console.log(a | b); // 7 (Binarnie: 0111)
// 0101
// 0011
// ----
// 0111

// XOR bitowe (^)
console.log(a ^ b); // 6 (Binarnie: 0110)
// 0101
// 0011
// ----
// 0110

// NOT bitowe (~)
console.log(~a); // -6 (Binarnie: 11111111111111111111111111111010 - reprezentacja uzupełnienia do dwóch)
// ~0101 => 1010 (w reprezentacji 32-bitowej ze znakiem i uzupełnieniu do dwóch daje -6)

// Przesunięcie bitowe w lewo (<<)
console.log(a << 1); // 10 (Binarnie: 1010) - mnożenie przez 2
console.log(a << 2); // 20 (Binarnie: 10100) - mnożenie przez 4

// Przesunięcie bitowe w prawo (>>)
console.log(a >> 1); // 2 (Binarnie: 0010) - dzielenie przez 2 (część ułamkowa odrzucana)

// Bez znakowe przesunięcie bitowe w prawo (>>>)
let c = -5; // Binarnie (uproszczone): 1111...1011
console.log(c >>> 1); // 2147483645 (Przesunięcie bitów i wstawienie 0 z lewej strony)
// Zwraca dużą liczbę dodatnią, ponieważ bity znaku są przesuwane i zastępowane zerami.

Krótkie Podsumowanie Operatorów Bitowych:

• & (AND): Sprawdza, czy oba bity są 1.
• | (OR): Sprawdza, czy co najmniej jeden bit jest 1.
• ^ (XOR): Sprawdza, czy bity są różne.
• ~ (NOT): Odwraca bity.
• <<: Przesuwa bity w lewo (mnożenie przez 2ⁿ).
• >>: Przesuwa bity w prawo (dzielenie przez 2ⁿ, zachowuje znak).
• >>>: Przesuwa bity w prawo (dzielenie przez 2ⁿ, wstawia 0 z lewej).

Operatory bitowe mogą być trudne do zrozumienia na początku, ale z praktyką staną się bardziej intuicyjne.

Operatory Inkrementacji/Dekrementacji

Służą do zwiększania lub zmniejszania wartości zmiennej o 1:

• ++ (inkrementacja): x++ (postinkrementacja – zwraca starą wartość, a potem inkrementuje), ++x (preinkrementacja – najpierw inkrementuje, a potem zwraca nową wartość)
• -- (dekrementacja): x-- (postdekrementacja), --x (predekrementacja)

Przykłady:

let i = 5;
console.log(i++); // wyświetli 5, a potem i będzie równe 6
console.log(++i); // wyświetli 7 (bo najpierw i zostało zwiększone)

let j = 10;
console.log(j--); // wyświetli 10, a potem j będzie równe 9
console.log(--j); // wyświetli 8

Wyrażenia i Ich Ewaluacja

Wyrażenie to kombinacja operandów i operatorów, która daje w wyniku jakąś wartość. Ewaluacja wyrażenia to proces obliczania tej wartości. Kolejność ewaluacji jest zgodna z priorytetem operatorów (np. mnożenie i dzielenie mają wyższy priorytet niż dodawanie i odejmowanie). Możemy używać nawiasów, aby wymusić inną kolejność:

let wynik = 2 + 3 * 4; // wynik to 14 (najpierw 3 * 4, potem dodawanie)
let wynik2 = (2 + 3) * 4; // wynik2 to 20 (najpierw (2 + 3), potem mnożenie)

Mam nadzieję, że ten artykuł był pomocny. Zachęcam do zostawiania komentarzy. W kolejnych częściach kursu będziemy omawiać instrukcje warunkowe i pętle.