📚 Masīvi

// Masīva izveide
const augļi = ["ābols", "bumbieris", "ķirsis"];
const skaitļi = [1, 2, 3, 4, 5];
const jaukts = [1, "teksts", true, null, { id: 1 }, [10, 20]];
const tukšs = [];
const no_konstruktora = new Array(5); // 5 tukšu slotu masīvs

// Piekļuve pēc indeksa (0 bāzēts)
console.log(augļi[0]);  // "ābols"
console.log(augļi[2]);  // "ķirsis"
console.log(augļi[-1]); // undefined! (nevis pēdējais)

// Pēdējie elementi
console.log(augļi[augļi.length - 1]);  // "ķirsis" (klasiskais)
console.log(augļi.at(-1));             // "ķirsis" (ES2022, pieļauj negatīvus)
console.log(augļi.at(-2));             // "bumbieris"

// Garums
console.log(augļi.length); // 3

// Mainīt elementu
augļi[1] = "aprikoze";
console.log(augļi); // ["ābols", "aprikoze", "ķirsis"]

// Pievienot "caur" indeksu (rada tukšumus!)
augļi[10] = "vīnogas"; // Atstāj 7 tukšus elementus!

let augļi = ["ābols", "bumbieris"];

// push – pievieno BEIGĀS
augļi.push("ķirsis");               // ["ābols", "bumbieris", "ķirsis"]
augļi.push("aprikoze", "plūme");    // var pievienot vairākus

// pop – noņem NO BEIGĀM, atgriež noņemto
const pēdējais = augļi.pop();       // "plūme"

// unshift – pievieno SĀKUMĀ (lēns lielos masīvos)
augļi.unshift("zemel.");            // ["zemel.", "ābols", ...]

// shift – noņem NO SĀKUMA
const pirmais = augļi.shift();      // "zemel."

// splice – pievieno/dzēš jebkurā vietā
// splice(sākumIndekss, cikDzēst, ...pievienot)
augļi.splice(1, 0, "mandarīns");    // Pievieno indeksā 1, nedzēš
augļi.splice(2, 1);                 // Dzēš 1 elementu indeksā 2
augļi.splice(1, 2, "citrons", "apelsīns"); // Aizstāj 2 ar 2

// delete – dzēš elementu, bet atstāj tukšumu
delete augļi[0]; // [undefined, ...]  ← parasti usar splice

// Izveidot jaunu masīvu no daļas
const pirmie_divi = augļi.slice(0, 2);  // Neizmaina oriģinālu
const pēdējie = augļi.slice(-2);        // Pēdējie 2
const kopija = augļi.slice();           // Sekla kopija

const cipari = [3, 1, 4, 1, 5, 9, 2, 6, 5];

// indexOf – atrod PIRMO pozīciju, vai -1
cipari.indexOf(1);       // 1
cipari.indexOf(7);       // -1 (nav)
cipari.lastIndexOf(1);   // 3 (pēdējā pozīcija)

// includes – vai elements pastāv?
cipari.includes(5);  // true
cipari.includes(7);  // false

// find – atrod PIRMO objektu atbilstošo nosacījumam
const darbinieki = [
    { id: 1, vārds: "Anna", nodaļa: "IT" },
    { id: 2, vārds: "Jānis", nodaļa: "Grāmatvedība" },
    { id: 3, vārds: "Marta", nodaļa: "IT" },
];
const anna = darbinieki.find(d => d.vārds === "Anna");
// { id: 1, vārds: "Anna", nodaļa: "IT" }

// findIndex – atrod indeksu
const martas_i = darbinieki.findIndex(d => d.vārds === "Marta"); // 2

// findLast / findLastIndex (ES2023)
const pēdējais_it = darbinieki.findLast(d => d.nodaļa === "IT");
// { id: 3, vārds: "Marta", ... }

// filter – visas atbilstošās
const it_darbinieki = darbinieki.filter(d => d.nodaļa === "IT");
// [Anna, Marta]

// sort() – kārto ORIĢINĀLAJĀ masīvā!
const augļi = ["Ķirsis", "Ābols", "Bumbieris"];
augļi.sort(); // ["Ābols", "Bumbieris", "Ķirsis"] (alfabētiski)

// SVARĪGI: sort ar skaitļiem bez salīdzinātāja darbojaspret!
[10, 9, 2, 1, 100].sort();  // [1, 10, 100, 2, 9] ← NEPAREIZI!

// Pareizā numeriskā kārtošana ar salīdzinātāja funkciju
[10, 9, 2, 1, 100].sort((a, b) => a - b);  // [1, 2, 9, 10, 100] ↑
[10, 9, 2, 1, 100].sort((a, b) => b - a);  // [100, 10, 9, 2, 1] ↓

// Objektu kārtošana pēc lauka
const produkti = [
    { nosaukums: "C tips", cena: 30 },
    { nosaukums: "A tips", cena: 10 },
    { nosaukums: "B tips", cena: 20 },
];

// Pēc cenas
produkti.sort((a, b) => a.cena - b.cena);

// Pēc nosaukuma (virkne)
produkti.sort((a, b) => a.nosaukums.localeCompare(b.nosaukums, "lv"));

// Neizmainīt oriģinālu (ES2023 toSorted)
const sakārtots = produkti.toSorted((a, b) => a.cena - b.cena);

// reverse()
[1, 2, 3].reverse(); // [3, 2, 1] (izmaina oriģinālu)
[1, 2, 3].toReversed(); // (ES2023, neizmaina)

const a = [1, 2, 3];
const b = [4, 5, 6];

// Apvienot masīvus
const kopā = a.concat(b);         // [1, 2, 3, 4, 5, 6]
const spread = [...a, ...b];      // [1, 2, 3, 4, 5, 6] (ieteicamais)
const ar_extra = [...a, 99, ...b];// [1, 2, 3, 99, 4, 5, 6]

// join – masīvs uz virkni
["a", "b", "c"].join();      // "a,b,c" (noklusējums ","
["a", "b", "c"].join(" - "); // "a - b - c"
["a", "b", "c"].join("");    // "abc"

// split uz masīvu
"a,b,c".split(",");   // ["a", "b", "c"]

// Array.from – pārveidot citāda veida kolekcijas
Array.from("Sveiki");          // ["S","v","e","i","k","i"]
Array.from({length: 5}, (_, i) => i * 2); // [0, 2, 4, 6, 8]
Array.from(new Set([1, 2, 2, 3]));        // [1, 2, 3]

// Array.of
Array.of(1, 2, 3);  // [1, 2, 3]

// Unikālie elementi
const ar_dublikātiem = [1, 2, 2, 3, 3, 3];
const unikālie = [...new Set(ar_dublikātiem)]; // [1, 2, 3]

// fill – aizpildīt ar vērtību
new Array(5).fill(0);      // [0, 0, 0, 0, 0]
[1,2,3,4].fill(0, 1, 3);  // [1, 0, 0, 4]

const koordinātas = [10, 20, 30];

// Pamata destrukturizācija
const [x, y, z] = koordinātas;
console.log(x, y, z); // 10 20 30

// Izlaist elementus
const [pirmais, , trešais] = koordinātas;
console.log(pirmais, trešais); // 10 30

// Noklusējuma vērtības
const [a = 0, b = 0, c = 0, d = 0] = [1, 2];
console.log(d); // 0 (noklusējums)

// Rest elements
const [galva, ...aste] = [1, 2, 3, 4, 5];
console.log(galva); // 1
console.log(aste);  // [2, 3, 4, 5]

// Mainīgo apmaiņa
let ka = 1, kb = 2;
[ka, kb] = [kb, ka];
console.log(ka, kb); // 2 1

// Funkcijas atgriešanas vērtība
function miniMax(masīvs) {
    return [Math.min(...masīvs), Math.max(...masīvs)];
}
const [min, max] = miniMax([3, 1, 4, 1, 5, 9]);
console.log(min, max); // 1 9