Operatory w JavaScript

W tym artykule wyjaśnimy operatory w JavaScript.

YouTube Video

Operatory w JavaScript

Operatory w JavaScript to symbole lub słowa kluczowe wykorzystywane do wykonywania obliczeń lub porównań na liczbach i zmiennych. Istnieją różne typy operatorów, z których każdy wykonuje inne operacje. Oto podsumowanie niektórych głównych operatorów:.

Operatory Arytmetyczne

Operatory arytmetyczne w JavaScript obejmują następujące:.

 1let a = 10; // Initialize variable 'a' with the value 10
 2let b = 3;  // Initialize variable 'b' with the value 3
 3
 4// Perform and display arithmetic operations between 'a' and 'b'
 5console.log("Addition (a + b):      ", a + b); // 13
 6console.log("Subtraction (a - b):   ", a - b); // 7
 7console.log("Multiplication (a * b):", a * b); // 30
 8console.log("Division (a / b):      ", a / b); // 3.333...
 9console.log("Modulus (a % b):       ", a % b); // 1
10
11// Demonstrate post-increment operation on 'a'
12// Output the current value of 'a' (10), then increment
13console.log("Post-increment (a++):  ", a++);
14// Display the incremented value of 'a' (11)
15console.log("Value of 'a' after increment:", a);
16
17// Demonstrate pre-increment operation on 'a'
18// Increment 'a' first (12) then output
19console.log("Pre-increment (++a):   ", ++a);
20
21// Demonstrate post-decrement operation on 'a'
22// Output the current value of 'a' (12), then decrement
23console.log("Post-decrement (a--):  ", a--);
24// Display the decremented value of 'a' (11)
25console.log("Value of 'a' after decrement:", a);
26
27// Demonstrate pre-decrement operation on 'a'
28// Decrement 'a' first (10) then output
29console.log("Pre-decrement (--a):   ", --a);

Operatory arytmetyczne wykonują podstawowe operacje matematyczne na liczbach. Oprócz dodawania i odejmowania można wykonać operacje takie jak modulo, inkrementacja i dekrementacja. Zwróć uwagę, że wartość zwrócona przez operator inkrementacji lub dekrementacji różni się w zależności od tego, czy operator znajduje się przed, czy po operancie.

Operatory Przypisania

Operatory przypisania w JavaScript obejmują następujące:.

 1let x = 10;
 2
 3x += 5;  // x = x + 5, so x becomes 15
 4console.log('After x += 5 : ', x);  // 15
 5
 6x -= 10;
 7console.log('After x -= 10 : ', x);  // 5
 8
 9x *= 3;
10console.log('After x *= 3 : ', x);  // 15
11
12x /= 3;
13console.log('After x /= 3 : ', x);  // 5
14
15x %= 2;
16console.log('After x %= 2 : ', x);  // 1

Operatory przypisania służą do przypisywania wartości do zmiennych lub aktualizowania wartości zmiennych. Oprócz zwykłego przypisania istnieją operatory przypisania do operacji arytmetycznych, takich jak dodawanie i reszta z dzielenia.

Operatory porównania

Operatory porównania w JavaScript obejmują następujące:.

 1console.log("5 == '5' evaluates to:", 5 == "5");   // true (because the values are equal)
 2console.log("5 === '5' evaluates to:", 5 === "5"); // false (because the types are different)
 3console.log("5 != '5' evaluates to:", 5 != "5");   // false
 4console.log("5 !== '5' evaluates to:", 5 !== "5"); // true
 5console.log("5 > 2 evaluates to:", 5 > 2);         // true
 6console.log("5 < 2 evaluates to:", 5 < 2);         // false
 7console.log("5 >= 5 evaluates to:", 5 >= 5);       // true
 8console.log("5 <= 4 evaluates to:", 5 <= 4);       // false
 9console.log("5 >= '5' evaluates to:", 5 >= "5");   // true
10console.log("5 <= '5' evaluates to:", 5 <= "5");   // true

• Operatory porównania porównują wartości i zwracają wartość true (prawda) lub false (fałsz).
• Operator równości (==) automatycznie konwertuje różne typy, jeśli to konieczne, przed wykonaniem porównania. Ścisły operator równości (===) nie wykonuje żadnej konwersji typów podczas porównania i zwraca true tylko wtedy, gdy obie wartości mają ten sam typ i tę samą wartość. Użycie ścisłego operatora równości (===) pomaga zapobiegać błędom spowodowanym niezamierzoną konwersją typów, dlatego zaleca się jego preferencyjne stosowanie.

Operatory logiczne

Operatory logiczne w JavaScript obejmują następujące:.

1let a = true;
2let b = false;
3
4console.log("a && b evaluates to:", a && b);  // false
5console.log("a || b evaluates to:", a || b);  // true
6console.log("!a evaluates to:", !a);          // false

Operatory logiczne są używane, gdy istnieje wiele warunków, aby ocenić ich kombinacje.

Priorytet operatorów logicznych

W JavaScript operatory logiczne są zwykle oceniane w kolejności: najpierw NOT, potem AND, a na końcu OR.

NOT ma najwyższy priorytet

NOT jest operatorem unarnym i jest oceniany z najwyższym priorytetem.

1console.log(!true || false);  // false

AND ma wyższy priorytet niż OR

AND ma wyższy priorytet niż OR, więc część AND jest oceniana jako pierwsza.

1console.log(true || false && false);  // true

W ten sposób część AND (&&) jest oceniana jako pierwsza, a jej wynik jest przekazywany do OR (||).

AND i OR wykonują krótkie obliczenie (short-circuit evaluation)

Operatory AND i OR w JavaScript wykonują krótkie obliczenie (short-circuit evaluation). Jeśli wynik można określić na podstawie wartości po lewej stronie, wyrażenie po prawej stronie nie jest oceniane.

1let a = false && console.log("This will not be printed");
2console.log(a);  // false
3
4let b = true || console.log("This will not be printed");
5console.log(b);  // true

W obu przypadkach console.log() nie zostanie wykonane.

Określ wyraźny priorytet

Poprzez jawne grupowanie wyrażeń za pomocą nawiasów, możesz zapobiec nieporozumieniom dotyczącym priorytetów.

1console.log(true || (false && false));  // true

Różnice między językiem naturalnym a interpretacją w programie

Podczas używania operatorów logicznych ważne jest, aby być świadomym dwuznaczności w języku naturalnym. Na przykład, mówiąc 'biały pies lub kot', może to oznaczać albo 'białego psa lub kota dowolnego koloru', albo 'białego psa lub białego kota'. W kodzie wyglądałoby to tak:.

1if (isWhite && isDog || isCat) {
2    console.log(' "A white dog" or "a cat of any color" ');
3}
4
5if (isWhite && (isDog || isCat)) {
6    console.log(' "A white dog" or "a white cat" ');
7}
8
9console.log(true || (false && false));  // true

Ponieważ język naturalny zawiera takie dwuznaczności, należy zachować ostrożność podczas kodowania lub projektowania.

Operator trójwartościowy (Operator warunkowy)

JavaScript zawiera operator trójargumentowy (operator warunkowy).

1let age = 20;
2let message = age >= 18 ? "Adult" : "Minor";
3console.log(message);  // "Adult"

Jest zapisany w formie warunek ? wartość jeśli prawda : wartość jeśli fałsz.

Operatory bitowe

JavaScript operatory bitowe obejmują następujące.

 1let x = 0x0F & 0x0C;
 2console.log("0x0F & 0x0C evaluates to:", x, "(0x0C, 12)");  // 0x0C (12)
 3
 4x = 0x04 | 0x02;
 5console.log("0x04 | 0x02 evaluates to:", x, "(0x06, 6)");  // 0x06 (6)
 6
 7x = 0x0F ^ 0x0C;
 8console.log("0x0F ^ 0x0C evaluates to:", x, "(0x03, 3)");  // 0x03 (3)
 9
10// The inverted number is represented as a negative value
11// because JavaScript numbers are stored as signed 32-bit integers.
12x = ~0x0C;
13console.log("~0x0C evaluates to:", x, "(-13, 0xF3)");  // 0xF3 (-13)
14
15x = 0x04 << 1;
16console.log("0x04 << 1 evaluates to:", x, "(0x08, 8)");    // 0x08 (8)
17x = 0x04 >> 1;
18console.log("0x04 >> 1 evaluates to:", x, "(0x02, 2)");    // 0x02 (2)

Operatory bitowe wykonują obliczenia na liczbach na poziomie pojedynczych bitów. Zazwyczaj są używane do przetwarzania na niskim poziomie.

Operatory typów

JavaScript operatory typów obejmują następujące.

1console.log(typeof "Hello");  // "string"
2console.log(typeof 42);       // "number"
3
4let arr = [1, 2, 3];
5console.log("arr instanceof Array : ", arr instanceof Array); // true

Operatory typów służą do sprawdzania typu wartości lub jej konwersji na określony typ.

Operator typeof zwraca typ zmiennej.

Operator instanceof sprawdza, czy obiekt należy do określonej klasy.

Podsumowanie

• Operatory arytmetyczne wykonują podstawowe obliczenia.
• Operatory przypisania przypisują lub aktualizują wartości w zmiennych.
• Operatory porównania porównują dwie wartości i zwracają wartość true lub false.
• Operatory logiczne oceniają kombinacje warunków.
• Operatory trójargumentowe umożliwiają tworzenie wyrażeń warunkowych w krótszej formie niż if.
• Operatory bitowe wykonują obliczenia na poziomie bitów.
• Operatory typów pozwalają sprawdzić typ wartości.

Możesz śledzić ten artykuł, korzystając z Visual Studio Code na naszym kanale YouTube. Proszę również sprawdzić nasz kanał YouTube.

YouTube Video