Operacje na zmiennych i typach danych w JavaScript (zmienne programowanie)

Operatory arytmetyczne i operatory przypisania

W JavaScript operatory arytmetyczne pozwalają na wykonywanie podstawowych operacji matematycznych na zmiennych liczbowych. Najczęściej używane operatory to:

• Dodawanie (+): Służy do dodawania dwóch wartości.

• Odejmowanie (-): Służy do odejmowania jednej wartości od drugiej.

• Mnożenie (*): Służy do mnożenia dwóch wartości.

• Dzielenie (/): Służy do dzielenia jednej wartości przez drugą.

• Modulo (%): Zwraca resztę z dzielenia.

Przykład w JavaScript:

let x = 10;
let y = 3;
let result = x + y;    // Wynik: 13
console.log(result);

result = x - y;        // Wynik: 7
console.log(result);

result = x * y;        // Wynik: 30
console.log(result);

result = x / y;        // Wynik: 3.3333
console.log(result);

result = x % y;        // Wynik: 1
console.log(result);

Operatory przypisania umożliwiają przypisanie wartości do zmiennej oraz modyfikowanie jej wartości za pomocą operacji matematycznych:

• Przypisanie (=): Przypisuje wartość do zmiennej.

• Dodaj i przypisz (+=): Dodaje wartość do zmiennej i przypisuje wynik do tej samej zmiennej.

• Odejmij i przypisz (-=): Odejmuje wartość od zmiennej i przypisuje wynik do tej samej zmiennej.

Przykład w JavaScript:

let number = 10; // Przypisanie wartości 10 do zmiennej
console.log(number);

number += 5;     // number = number + 5, wynik: 15
console.log(number);

number -= 3;     // number = number - 3, wynik: 12
console.log(number);

Typy zmiennych i ich reprezentacja

W JavaScript mamy do dyspozycji różnorodne typy zmiennych, które można podzielić na kilka głównych kategorii:

Typy liczbowe:

• Integer: W JavaScript wszystkie liczby są przechowywane w postaci zmiennoprzecinkowej, jednak w kontekście operacji możemy mówić o liczbach całkowitych (integer).

• Float: Liczby zmiennoprzecinkowe, np. 3.14.

Przykład w JavaScript:

let integerNumber = 5;    // Liczba całkowita
let floatNumber = 3.14;   // Liczba zmiennoprzecinkowa
console.log(integerNumber, floatNumber);

Typy znakowe (String): Przechowują sekwencje znaków, takie jak teksty. Możemy używać cudzysłowów pojedynczych lub podwójnych do ich definiowania.

Przykład w JavaScript:

let name = "John Doe";    // Typ string
let char = 'a';           // Typ string, pojedynczy znak
console.log(name, char);

Typy logiczne (Boolean): Przechowują wartości true lub false, które często są wynikiem operacji porównawczych.

Przykład w JavaScript:

let isValid = true;        // Typ boolean
let hasAccess = false;     // Typ boolean
console.log(isValid, hasAccess);

Zmienna a typ danych

W JavaScript, zmienne mogą dynamicznie zmieniać swój typ w trakcie działania programu. Wartość zmiennej jest kluczowym elementem, który determinuje jej typ danych.

Przykład:

let data = 10;             // Typ number
console.log(typeof data);  // Wypisuje: number

data = "Tekst";            // Typ string
console.log(typeof data);  // Wypisuje: string

data = 3.14;               // Typ number (float)
console.log(typeof data);  // Wypisuje: number

data = true;               // Typ boolean
console.log(typeof data);  // Wypisuje: boolean

Typy zmiennych lokalnych i globalnych

Typy zmiennych mogą także wpływać na ich zakres działania w programie:

• Zmienne lokalne: Są dostępne tylko w obrębie funkcji, w której zostały zadeklarowane.

• Zmienne globalne: Są dostępne w całym programie, niezależnie od funkcji.

Przykład:

let globalVar = "Jestem globalna"; // Zmienna globalna

function example() {
    let localVar = "Jestem lokalna"; // Zmienna lokalna
    console.log(globalVar); // Dostęp do zmiennej globalnej
    console.log(localVar);  // Dostęp do zmiennej lokalnej
}

example();
console.log(globalVar);     // Dostęp do zmiennej globalnej
// console.log(localVar);   // Błąd, brak dostępu do zmiennej lokalnej

Używanie zmiennych globalnych powinno być ograniczone, aby uniknąć problemów z zarządzaniem stanem aplikacji.

Zmienne statyczne i dynamiczne a tworzenie efektywnego kodu

Zmienne statyczne, które są stałe w trakcie działania programu, oraz zmienne dynamiczne, które mogą zmieniać swój typ i wartość, mają różne zastosowania w programowaniu. Zrozumienie różnic między nimi pozwala na tworzenie bardziej efektywnego kodu. Zmienne dynamiczne, chociaż elastyczne, mogą prowadzić do nieoczekiwanych błędów, jeśli nie są używane ostrożnie. Natomiast zmienne statyczne zapewniają stabilność i przewidywalność w działaniu programu.

Przykład w JavaScript dla zmiennej dynamicznej:

let dynamicVar = 42;    // Typ number
console.log(dynamicVar); // Wypisuje: 42

dynamicVar = "Hello";   // Typ zmienia się na string
console.log(dynamicVar); // Wypisuje: Hello

Przykład zmiennej statycznej w JavaScript:

const staticVar = 42;    // Zmienna stała, nie można jej zmienić
console.log(staticVar);  // Wypisuje: 42

// staticVar = "Hello";  // Błąd: Próba zmiany wartości stałej

Stosowanie zmiennych dynamicznych i statycznych zależy od kontekstu i potrzeb aplikacji. Ważne jest, aby świadomie wybierać odpowiedni typ zmiennej, aby zachować stabilność i czytelność kodu.