📦 Mainīgie un datu tipi

// var  – vecais veids (izvairīties no izmantošanas!)
var vecs = "es esmu var";

// let  – mainīga vērtība (var mainīt)
let skaits = 42;
skaits = 100; // OK

// const – konstante (nevar mainīt atsauci)
const PI = 3.14159;
// PI = 3; // ❌ TypeError: Assignment to constant variable

// const ar objektu/masīvu – saturu var mainīt!
const lietotājs = { vārds: "Anna" };
lietotājs.vārds = "Jānis"; // ✅ Darbojas
// lietotājs = {}; // ❌ Nedarbojas

// Vairāki mainīgie vienā rindiņā
let x = 1, y = 2, z = 3;

// Destrukturizācija (ērti no masīviem/objektiem)
const [a, b, c] = [10, 20, 30];
const { vārds, vecums } = { vārds: "Anna", vecums: 28 };
console.log(vārds, vecums); // Anna 28

// ================================
// PRIMITĪVIE TIPI (7 tipi)
// ================================

// 1. Number – skaitļi (veseli un decimāli)
let vesels = 42;
let decimāls = 3.14;
let negatīvs = -7;
let liels = 1_000_000; // Atdalītājs lasāmībai (ES2021)
let bezgalīgs = Infinity;
let neSkaitlis = NaN; // Not a Number

// 2. String – teksta virkne
let vienkārš = "Sveiki";
let dubultpēd = 'Pasaule';
let template = `Sveiki, ${vesels} pasaulē!`; // Template literal

// 3. Boolean – patiesums
let patiess = true;
let nepatiess = false;

// 4. Undefined – mainīgais deklarēts, bet nav vērtības
let nedefinēts;
console.log(nedefinēts); // undefined

// 5. Null – apzināta "nav vērtības"
let tukšs = null;

// 6. BigInt – ļoti lieli skaitļi
const milzīgs = 9007199254740991n; // Pievieno n galā

// 7. Symbol – unikāls identifikators
const simbols = Symbol("apraksts");

// ================================
// REFERENCES TIPS
// ================================

// Object – atslēga/vērtība pāri
const auto = { marka: "BMW", gads: 2022, elektrisks: false };

// Array – sakārtots saraksts (tehniski objekts)
const augļi = ["ābols", "bumbieris", "ķirsis"];

// Function – arī ir objekts
function skaitīt() { return 42; }

// ================================
// typeof operators
// ================================
console.log(typeof 42);           // "number"
console.log(typeof "teksts");     // "string"
console.log(typeof true);         // "boolean"
console.log(typeof undefined);    // "undefined"
console.log(typeof null);         // "object" ← KĻŪDA valodā! Tas ir null
console.log(typeof {});           // "object"
console.log(typeof []);           // "object" (masīvs = objekts)
console.log(typeof function(){}); // "function"

// Pārbaudīt vai masīvs:
console.log(Array.isArray([]));   // true
console.log(Array.isArray({}));   // false

// ================================
// Eksplicītā konversija (apzināta)
// ================================

// Uz skaitli
Number("42")         // 42
Number("3.14")       // 3.14
Number(true)         // 1
Number(false)        // 0
Number(null)         // 0
Number(undefined)    // NaN
Number("abc")        // NaN
parseInt("42px")     // 42  (ņem skaitli no sākuma)
parseFloat("3.14em") // 3.14

// Uz virkni
String(42)           // "42"
String(true)         // "true"
String(null)         // "null"
(42).toString()      // "42"
(255).toString(16)   // "ff" (heksadecimāls)

// Uz boolean
Boolean(0)           // false
Boolean("")          // false
Boolean(null)        // false
Boolean(undefined)   // false
Boolean(NaN)         // false
Boolean(1)           // true
Boolean("teksts")    // true
Boolean([])          // true (tukšs masīvs = true!)
Boolean({})          // true (tukšs objekts = true!)

// ================================
// Implicitā konversija (automātiska)
// ================================
"5" + 3      // "53" (skaitlis → virkne, jo + irkonkatenācija)
"5" - 3      // 2   (virkne → skaitlis, jo - ir atņemšana)
"5" * "2"   // 10
true + 1     // 2
false + 1    // 1
null + 1     // 1

// Labākā prakse: izmantot === (striktu salīdzinājumu)
"5" == 5     // true  (konvertējas tipi!)
"5" === 5    // false (strikts – tipi ≠)

// Template literāļi – backtick " ` " pēdiņas
const vārds = "Anna";
const vecums = 28;

// Veco veidu konkatenācija
const vecs = "Sveiki, " + vārds + "! Jums ir " + vecums + " gadi.";

// Jaunais veids – template literals
const jaunais = `Sveiki, ${vārds}! Jums ir ${vecums} gadi.`;

// Var ievietot jebkuru izteiksmi
const cena = 9.99;
console.log(`Cena ar PVN: €${(cena * 1.21).toFixed(2)}`);

// Vairāku rindiņu virknes
const html = `
  <div class="karte">
    <h2>${vārds}</h2>
    <p>Vecums: ${vecums}</p>
  </div>
`;

// "Tagged" template literals (progresīvs)
function izcelt(virknes, ...vērtības) {
    return virknes.reduce((rezultāts, virkne, i) => {
        return rezultāts + virkne + (vērtības[i] ? `<strong>${vērtības[i]}</strong>` : "");
    }, "");
}

const ziņa = izcelt`Sveiki, ${vārds}! Jums ir ${vecums} gadi.`;
// → "Sveiki, <strong>Anna</strong>! Jums ir <strong>28</strong> gadi."

// Globālais tvērums
let globāls = "Es esmu visur";

function piemērs() {
    // Funkcijas tvērums
    let lokāls = "Es esmu tikai šeit";
    console.log(globāls); // "Es esmu visur" ✅

    if (true) {
        // Bloka tvērums
        let bloka = "Es esmu blokā";
        var vecaisFunkcijas = "var ignorē bloku";
        console.log(lokāls); // ✅
        console.log(bloka);  // ✅
    }

    // console.log(bloka); // ❌ ReferenceError
    console.log(vecaisFunkcijas); // ✅ var "izkļūst" no bloka
}

piemērs();
// console.log(lokāls); // ❌ ReferenceError

// ================================
// Closure (noslēgums)
// ================================
function izveidotSkaitītāju() {
    let skaits = 0; // Šis mainīgais "dzīvo" closure iekšā

    return {
        pieaugums: () => ++skaits,
        samazinājums: () => --skaits,
        iegūt: () => skaits,
    };
}

const skaitītājs = izveidotSkaitītāju();
skaitītājs.pieaugums(); // 1
skaitītājs.pieaugums(); // 2
skaitītājs.samazinājums(); // 1
console.log(skaitītājs.iegūt()); // 1