📝 Zmienne i stałe

KitsuneScript oferuje dwa sposoby deklarowania wartości: zmienne (let) i stałe (const).

Zmienne (let)

Słowo kluczowe let tworzy zmienną, której wartość można zmieniać:

let x = 10;
print(x);  // 10

x = 20;     // OK - można zmienić wartość
print(x);  // 20

let name = "Kitsune";
name = "Fox";  // OK
        

Stałe (const)

Słowo kluczowe const tworzy stałą - wartość, której nie można zmienić:

const PI = 3.14159;
print(PI);  // 3.14159

// PI = 3;  // BŁĄD! Nie można zmienić stałej

const MAX_SIZE = 100;
const APP_NAME = "MyApp";
        

💡 Konwencja

Stałe zazwyczaj nazywa się WIELKIMI_LITERAMI z podkreślnikami, ale to tylko konwencja - język tego nie wymusza.

Deklaracja bez wartości

Zmienna może być zadeklarowana bez wartości początkowej:

let value;
print(value);  // null

value = 42;
print(value);  // 42
        

Wielokrotna deklaracja

Możesz zadeklarować wiele zmiennych w jednej linii:

// Multiple assignment
let a, b, c = 1, 2, 3;
print(a, b, c);  // 1 2 3

// Wszystkie tę samą wartość
let x = y = z = 0;
print(x, y, z);  // 0 0 0
        

Destructuring

Rozpakowywanie list i map do zmiennych:

// List destructuring
let [x, y, z] = [1, 2, 3];
print(x, y, z);  // 1 2 3

// Z wartością domyślną
let [a, b, c = 100] = [10, 20];
print(a, b, c);  // 10 20 100

// Map destructuring
let config = {host: "localhost", port: 8080};
let {host, port, timeout = 5000} = config;
print(host);     // "localhost"
print(port);     // 8080
print(timeout);  // 5000 (domyślna wartość)
        

Zakres (scope)

Zmienne są dostępne w bloku, w którym zostały zadeklarowane:

let globalVar = "global";

if (true) {
    let blockVar = "block";
    print(globalVar);  // OK - widoczna
    print(blockVar);   // OK - widoczna
}

print(globalVar);  // OK
// print(blockVar);  // BŁĄD! Nie widoczna poza blokiem
        

Nullish Assignment (??=)

Przypisz wartość tylko jeśli zmienna jest null:

let value = null;
value ??= 42;     // value = 42 (bo była null)
print(value);     // 42

value ??= 100;    // Nie zmienia (bo value != null)
print(value);     // 42
        

Logical Assignment

// ||= przypisz jeśli falsy (false, 0, "", null)
let a = false;
a ||= "default";
print(a);  // "default"

// &&= przypisz jeśli truthy
let b = true;
b &&= "assigned";
print(b);  // "assigned"
        

Compound Assignment

Skrócone operatory przypisania:

let x = 10;

x += 5;   // x = x + 5 → 15
x -= 3;   // x = x - 3 → 12
x *= 2;   // x = x * 2 → 24
x /= 4;   // x = x / 4 → 6
x %= 4;   // x = x % 4 → 2

print(x);  // 2
        

Inkrementacja i dekrementacja

let i = 0;

i++;       // postfix: zwraca 0, potem i = 1
++i;       // prefix: i = 2, zwraca 2
i--;       // postfix: zwraca 2, potem i = 1
--i;       // prefix: i = 0, zwraca 0

print(i);  // 0
        

⚠️ Różnica prefix/postfix

++i najpierw zwiększa, potem zwraca wartość. i++ najpierw zwraca wartość, potem zwiększa. Ma to znaczenie w wyrażeniach!

Podsumowanie

Słowo kluczowe	Opis	Zmienialność
`let`	Zmienna	✅ Można zmienić
`const`	Stała	❌ Nie można zmienić