🔄 Cikli

// Pamata for cilpa
for (let i = 0; i < 5; i++) {
    console.log("Iterācija:", i);
} // 0, 1, 2, 3, 4

// Atpakaḷ skaitīšana
for (let i = 10; i >= 0; i--) {
    console.log(i);
}

// Soļi pa 2
for (let i = 0; i <= 20; i += 2) {
    console.log(i); // 0, 2, 4, ... 20
}

// Masīva iterēšana ar for (vecs veids)
const augļi = ["ābols", "bumbieris", "ķirsis"];
for (let i = 0; i < augļi.length; i++) {
    console.log(`${i}: ${augļi[i]}`);
}

// Ligzdoti cikli - reizināšanas tabula
for (let i = 1; i <= 3; i++) {
    for (let j = 1; j <= 3; j++) {
        console.log(`${i} × ${j} = ${i * j}`);
    }
}

// while – pārbauda PIRMS izpildes
let skaits = 0;
while (skaits < 5) {
    console.log("Skaits:", skaits);
    skaits++;
}

// do-while – pārbauda PĒC izpildes (min 1 reize)
let x = 10;
do {
    console.log("x =", x);
    x++;
} while (x < 5); // Izpildīsies VIENU reizi pat ja nosacījums false

// Praksē: lietotāja ievades gaidīšana (Node.js piemērs)
let mēģinājumi = 0;
const maks = 3;
let sekmīgs = false;

while (mēģinājumi < maks && !sekmīgs) {
    // Parole pārbaudīšana
    const parole_ok = true; // simulācija
    if (parole_ok) {
        sekmīgs = true;
    } else {
        mēģinājumi++;
        console.log(`Kļūda. Atlikuši: ${maks - mēģinājumi} mēģinājumi`);
    }
}

// for...of  – iterē VĒRTĪBAS (masīvi, virknes, Map, Set)
const pilsētas = ["Rīga", "Liepāja", "Daugavpils"];
for (const pilsēta of pilsētas) {
    console.log(pilsēta); // Rīga, Liepāja, Daugavpils
}

// Ar indeksu izmantojot entries()
for (const [indekss, pilsēta] of pilsētas.entries()) {
    console.log(`${indekss + 1}. ${pilsēta}`);
}

// Virknes iterēšana
for (const burts of "Sveiki") {
    console.log(burts); // S, v, e, i, k, i
}

// Map un Set
const skaitļi = new Set([1, 2, 2, 3, 3, 3]);
for (const sk of skaitļi) {
    console.log(sk); // 1, 2, 3 (unikāli!)
}

// --------------------------------
// for...in  – iterē ATSLĒGAS (objekti)
const lietotājs = { vārds: "Anna", vecums: 28, pilsēta: "Rīga" };
for (const atslēga in lietotājs) {
    console.log(`${atslēga}: ${lietotājs[atslēga]}`);
}
// vārds: Anna
// vecums: 28
// pilsēta: Rīga

const skaitļi = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

// forEach – tikai izpilda, neatgriež jaunu masīvu
skaitļi.forEach((sk, i) => console.log(`${i}: ${sk}`));

// map – transformē katru elementu, atgriež JAUNU masīvu
const kvadrāti = skaitļi.map(sk => sk ** 2);
// [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

// filter – atstāj tikai nosacījumam atbilstošos
const pāra = skaitļi.filter(sk => sk % 2 === 0);
// [2, 4, 6, 8, 10]

// reduce – saliek viesā kopā uz vienu vērtību
const summa = skaitļi.reduce((uzkrāts, sk) => uzkrāts + sk, 0);
// 55

// find – atrod PIRMO atbilstošo elementu
const pirmais_lielāks = skaitļi.find(sk => sk > 5);
// 6

// findIndex – atrod indeksu
const indekss = skaitļi.findIndex(sk => sk > 5);
// 5

// some – vai kaut viens atbilst?
const ir_liels = skaitļi.some(sk => sk > 9);  // true

// every – vai visi atbilst?
const visi_pozitīvi = skaitļi.every(sk => sk > 0); // true

// flat – iztaisno ligzdotus masīvus
const ligzdots = [[1, 2], [3, [4, 5]]];
ligzdots.flat();    // [1, 2, 3, [4, 5]]
ligzdots.flat(2);   // [1, 2, 3, 4, 5]
ligzdots.flat(Infinity); // visi līmeņi

// flatMap – map + flat(1)
const teikumi = ["Sveiki pasaule", "Jauki laiki"];
const vārdi = teikumi.flatMap(t => t.split(" "));
// ["Sveiki", "pasaule", "Jauki", "laiki"]

// break – pilnībā pārtrauc cilpu
for (let i = 0; i < 10; i++) {
    if (i === 5) break;
    console.log(i); // 0, 1, 2, 3, 4
}

// continue – izlaiž šo iterāciju, turpina nākamo
for (let i = 0; i < 10; i++) {
    if (i % 2 === 0) continue; // Izlaiž pāra skaitļus
    console.log(i); // 1, 3, 5, 7, 9
}

// Iezīme (label) – break/continue ligzdotām cilpām
ārējā: for (let i = 0; i < 3; i++) {
    for (let j = 0; j < 3; j++) {
        if (j === 1) continue ārējā; // Izlaiž ārējo iterāciju
        console.log(i, j);
    }
}
// 0 0, 1 0, 2 0  ← j=1 un j=2 izlaisti

// break while
let attempts = 0;
while (true) { // "bezgalīga" cilpa
    attempts++;
    if (attempts >= 5) {
        console.log("Pārtraucam pēc", attempts, "mēģinājumiem");
        break;
    }
}

// Vairākas masīva metodes secīgi
const produkti = [
    { nosaukums: "Ābols",    cena: 0.50, kategorija: "augļi" },
    { nosaukums: "Bumbieris",cena: 1.20, kategorija: "augļi" },
    { nosaukums: "Burkāns",  cena: 0.30, kategorija: "dārzeņi" },
    { nosaukums: "Ķirsis",   cena: 2.50, kategorija: "augļi" },
    { nosaukums: "Kāposts",  cena: 0.90, kategorija: "dārzeņi" },
];

// 1. Atrast augļus, 2. Sakārtot pēc cenas, 3. Iegūt nosaukumus
const dārgie_augļi = produkti
    .filter(p => p.kategorija === "augļi")
    .sort((a, b) => b.cena - a.cena)
    .map(p => `${p.nosaukums} (€${p.cena.toFixed(2)})`);

console.log(dārgie_augļi);
// ["Ķirsis (€2.50)", "Bumbieris (€1.20)", "Ābols (€0.50)"]

// Kopējā augļu vērtība
const kopā = produkti
    .filter(p => p.kategorija === "augļi")
    .reduce((summa, p) => summa + p.cena, 0);

console.log("Augļu vērtība: €" + kopā.toFixed(2)); // €4.20