🔧 Operatori

let a = 10, b = 3;

a + b   // 13  – Saskaitīšana
a - b   // 7   – Atņemšana
a * b   // 30  – Reizināšana
a / b   // 3.333.. – Dalīšana
a % b   // 1   – Modulis (atlikums no dalīšanas)
a ** b  // 1000 – Kāpināšana (ES2016)
Math.floor(a / b) // 3 – Vesels dalījums

// Inkrements un dekrements
let x = 5;
x++;   // 5 (atgriež PIRMS pieskaita)
++x;   // 7 (pieskaita PIRMS atgriež)
x--;   // 7 (atgriež PIRMS atņem)
--x;   // 5

// Bieži iepauzē
console.log(10 % 2); // 0 – pāra skaitlis
console.log(7 % 2);  // 1 – nepāra skaitlis

// Stīgu "saskaitīšana"
"Sveiki" + " " + "pasaule!" // "Sveiki pasaule!"
"Izmaksa: €" + (2.5 * 4)    // "Izmaksa: €10"

let n = 10;

n = 5;   // n = 5   (piešķiršana)
n += 3;  // n = 8   (n = n + 3)
n -= 2;  // n = 6   (n = n - 2)
n *= 4;  // n = 24  (n = n * 4)
n /= 6;  // n = 4   (n = n / 6)
n %= 3;  // n = 1   (n = n % 3)
n **= 4; // n = 1   (n = n ** 4)

// Loģiskās piešķiršanas (ES2021)
let teksts = null;
teksts ||= "noklusējuma vērtība"; // ja teksts ir falsy, piešķir
console.log(teksts); // "noklusējuma vērtība"

let reāls = "īstā vērtība";
reāls &&= reāls.toUpperCase(); // ja reāls ir truthy, piešķir
console.log(reāls); // "ĪSTĀ VĒRTĪBA"

let var1 = null;
var1 ??= "aizstājējs"; // tikai ja null vai undefined
console.log(var1); // "aizstājējs"

// == vs ===  (ļoti svarīgi!)
5 == "5"    // true  – abstraktā vienādojums (tipskonvertējas)
5 === "5"   // false – strikts vienādojums (tipi ≠)
5 === 5     // true

null == undefined   // true  (īpaša izņēmuma gadījums)
null === undefined  // false

// Nevienlīdzība
5 != "5"    // false (abstraktā)
5 !== "5"   // true  (strikts) ← IZMANTOJIET ŠO!

// Lielāks / mazāks
3 > 2      // true
3 >= 3     // true
2 < 3      // true
2 <= 2     // true

// Virkņu salīdzinājums (alfabētiski)
"ābols" < "bumbieris" // true (a < b)
"Z" < "a"             // true (lielie burti ir "mazāki")

// && – UN (abi jābūt patiess)
true && true    // true
true && false   // false

// || – VAI (vismaz viens jābūt patiess)
true || false   // true
false || false  // false

// ! – NOLIEGUMS
!true   // false
!false  // true
!!0     // false (dubults noliegums = konvertē uz boolean)
!!"teksts" // true

// ========================================
// Short-circuit evaluation (ļoti noderīgi)
// ========================================

// && – ja pirmais ir falsy, atgriež to; citādi atgriež otro
null && "vērtība"    // null    (apstājas pie null)
"pirmais" && "otrais" // "otrais" (pāriet uz otro)

// Bieža izmantošana: nosacīta renderēšana
const lietotājs = { vārds: "Anna" };
const ziņa = lietotājs && `Sveiki, ${lietotājs.vārds}!`;
console.log(ziņa); // "Sveiki, Anna!"

// || – ja pirmais ir truthy, atgriež to; citādi atgriež otro
null || "noklusējums"   // "noklusējums"
"vērtība" || "cita"    // "vērtība"

// Noklusējuma vērtība
const ports = process?.env?.PORT || 3000;

// ?? – Nullish coalescing (tikai null/undefined, nevis 0 vai "")
null ?? "noklusējums"       // "noklusējums"
undefined ?? "noklusējums"  // "noklusējums"
0 ?? "noklusējums"          // 0  (atšķirībā no ||, 0 tiek saglabāts!)
"" ?? "noklusējums"         // ""
false ?? "noklusējums"      // false

// nosacījums ? vērtībaJa : vērtībaJaNē
const vecums = 20;
const statuss = vecums >= 18 ? "pilngadīgs" : "nepilngadīgs";
console.log(statuss); // "pilngadīgs"

// Izmantošana HTML veidošanā
const pieteicies = true;
const html = `<button>${pieteicies ? "Iziet" : "Pieteikties"}</button>`;

// Ternāra ligzdošana (izvairīties; uzrakstiet if/else)
const skaits = 15;
const etiķete = skaits < 0
    ? "negatīvs"
    : skaits === 0
        ? "nulle"
        : "pozitīvs";

// Ternārais ar funkcijas izsaukumu
function apstrādāt(dati) {
    dati ? console.log("Ir dati:", dati) : console.warn("Nav datu");
}

// ========================================
// Optional Chaining ?.  (ES2020)
// ========================================
// Problēma: TypeError ja starpvērtība ir null/undefined
// const iela = lietotājs.adrese.iela; // Avārija ja adrese nav!

const lietotājs = { vārds: "Anna" };

// Drošā piekļuve
const iela = lietotājs?.adrese?.iela;   // undefined (nav kļūda)
const pasta = lietotājs?.kontakti?.email ?? "nav norādīts";

// Ar masīviem
const pirmais = lietotājs?.hobiji?.[0]; // undefined

// Ar metodēm
const liels = lietotājs?.vārds?.toUpperCase(); // "ANNA"
const rez   = lietotājs?.neeksistē?.();        // undefined

// ========================================
// Spread operators ...  (ES2015)
// ========================================
// Masīvu apvienošana
const a = [1, 2, 3];
const b = [4, 5, 6];
const kopā = [...a, ...b];          // [1, 2, 3, 4, 5, 6]
const kopija = [...a];              // Sekla kopija

// Objektu apvienošana
const pamata = { x: 1, y: 2 };
const papildu = { y: 99, z: 3 };   // y tiks pārrakstīts
const apvienots = { ...pamata, ...papildu }; // {x:1, y:99, z:3}

// Funkciju argumenti
function summa(...skaitļi) {
    return skaitļi.reduce((s, n) => s + n, 0);
}
summa(1, 2, 3);          // 6
summa(...[10, 20, 30]);  // 60

// ========================================
// Bitwise operators (reti izmantoti)
// ========================================
5 & 3   // 1   (AND)
5 | 3   // 7   (OR)
5 ^ 3   // 6   (XOR)
~5      // -6  (NOT)
5 << 1  // 10  (Left shift)
5 >> 1  // 2   (Right shift)

// Praktisks: ātrs noapaļošanas veids
~~3.7   // 3 (ekvivalents Math.floor() pozitīviem skaitļiem)