Metody tablic wyższego rzędu

const podwoj = (x) => x * 2;
const dodajTrzy = (x) => x + 3;

// funkcja w zmiennej, w tablicy, jako argument
const operacje = [podwoj, dodajTrzy, Math.sqrt];
console.log(typeof podwoj, operacje.length);

// własna funkcja wyższego rzędu: wywołuje callback dla każdego elementu
function dlaKazdego(tablica, callback) {
  for (let i = 0; i < tablica.length; i++) {
    callback(tablica[i], i);
  }
}

dlaKazdego([10, 20, 30], (wartosc, indeks) => {
  console.log(`[${indeks}] = ${wartosc}`);
});

// przekazujemy funkcję, NIE jej wynik
dlaKazdego([16, 81], Math.sqrt);   // dobrze: Math.sqrt to funkcja
// dlaKazdego([16, 81], Math.sqrt()) // źle: Math.sqrt() to NaN, nie funkcja

const koszyk = [
  { nazwa: 'Klawiatura', cena: 199 },
  { nazwa: 'Mysz', cena: 89 },
  { nazwa: 'Podkładka', cena: 25 },
];

koszyk.forEach((produkt, i) => {
  console.log(`${i + 1}. ${produkt.nazwa} – ${produkt.cena} zł`);
});

// forEach nic nie zwraca – to częste zaskoczenie
const wynik = koszyk.forEach((p) => p.cena);
console.log(wynik);

const ceny = [100, 250, 40];

const brutto = ceny.map((c) => c * 1.23);
console.log(brutto);

const sformatowane = ceny.map((c) => `${c.toFixed(2)} zł`);
console.log(sformatowane);

// obiekty → inne obiekty (bez zmiany oryginałów – spread kopiuje)
const produkty = [
  { nazwa: 'Klawiatura', cena: 199 },
  { nazwa: 'Mysz', cena: 89 },
];
const przecenione = produkty.map((p) => ({ ...p, cena: p.cena - 20 }));
console.log(przecenione[0].cena, produkty[0].cena);

// obiekty → tylko jedna właściwość
const nazwy = produkty.map((p) => p.nazwa);
console.log(nazwy);

// map z indeksem
console.log(['a', 'b', 'c'].map((litera, i) => `${i}:${litera}`));

const oceny = [5, 2, 4, 1, 3, 6];
console.log(oceny.filter((o) => o >= 3));           // [5, 4, 3, 6]
console.log(oceny.filter((o) => o > 10));           // [] – nic nie pasuje, ale to tablica

const uczniowie = [
  { imie: 'Ala', klasa: '3TP', srednia: 4.8 },
  { imie: 'Bartek', klasa: '3TI', srednia: 3.1 },
  { imie: 'Celina', klasa: '3TP', srednia: 3.9 },
];
const zTP = uczniowie.filter((u) => u.klasa === '3TP');
console.log(zTP.map((u) => u.imie));

// usuwanie elementu „bez usuwania”: zostaw wszystkie poza jednym
const bezBartka = uczniowie.filter((u) => u.imie !== 'Bartek');
console.log(bezBartka.length, uczniowie.length); // oryginał dalej ma 3

const produkty = [
  { id: 1, nazwa: 'Klawiatura', cena: 199 },
  { id: 2, nazwa: 'Mysz', cena: 89 },
  { id: 3, nazwa: 'Monitor', cena: 899 },
];

const mysz = produkty.find((p) => p.id === 2);
console.log(mysz.nazwa);

const brak = produkty.find((p) => p.id === 99);
console.log(brak);                    // undefined – uwaga przy brak.nazwa!
console.log(brak?.nazwa ?? 'nie znaleziono');

console.log(produkty.findIndex((p) => p.cena > 100));     // 0 – klawiatura
console.log(produkty.findLast((p) => p.cena > 100).nazwa); // Monitor – od końca

// includes dla prymitywów, at(-1) dla ostatniego elementu
const tagi = ['js', 'html', 'css'];
console.log(tagi.includes('css'), tagi.at(-1));

const pola = ['Jan', 'Kowalski', '', 'jan@example.com'];
console.log(pola.some((p) => p.trim() === ''));   // true – jest puste pole
console.log(pola.every((p) => p.trim() !== ''));  // false

const oceny = [4, 5, 3, 5];
console.log(oceny.every((o) => o >= 3));  // true – zdał wszystko
console.log(oceny.some((o) => o === 6));  // false – ani jednej szóstki

// pusta tablica: every → true, some → false (nic nie zaprzecza / nic nie potwierdza)
console.log([].every((x) => x > 100), [].some((x) => x > 100));

const koszyk = [
  { nazwa: 'Klawiatura', cena: 199, ilosc: 1 },
  { nazwa: 'Mysz', cena: 89, ilosc: 2 },
  { nazwa: 'Podkładka', cena: 25, ilosc: 3 },
];

// suma wartości koszyka
const razem = koszyk.reduce((suma, p) => suma + p.cena * p.ilosc, 0);
console.log(razem);

// największa cena (akumulator = dotychczasowe maksimum)
const maks = koszyk.reduce((m, p) => (p.cena > m ? p.cena : m), 0);
console.log(maks);

// zliczanie: akumulator jest obiektem
const glosy = ['tak', 'nie', 'tak', 'tak', 'nie'];
const zliczone = glosy.reduce((acc, g) => {
  acc[g] = (acc[g] ?? 0) + 1;
  return acc; // z klamrami trzeba zwrócić akumulator!
}, {});
console.log(zliczone);

// krok po kroku – zobacz, jak zmienia się akumulator
[1, 2, 3].reduce((acc, x) => {
  console.log(`acc=${acc}, x=${x} → ${acc + x}`);
  return acc + x;
}, 0);

const liczby = [10, 9, 100, 1];
console.log([...liczby].sort());              // leksykograficznie – źle dla liczb
console.log([...liczby].sort((a, b) => a - b)); // rosnąco
console.log([...liczby].sort((a, b) => b - a)); // malejąco

// napisy po polsku
const imiona = ['Żaneta', 'adam', 'Łukasz', 'Celina'];
console.log([...imiona].sort());                                 // kody znaków: wielkie przed małymi, Ł i Ż na końcu
console.log([...imiona].sort((a, b) => a.localeCompare(b, 'pl'))); // alfabetycznie po polsku

// obiekty po właściwości
const produkty = [
  { nazwa: 'Monitor', cena: 899 },
  { nazwa: 'Mysz', cena: 89 },
  { nazwa: 'Klawiatura', cena: 199 },
];
const wgCeny = [...produkty].sort((a, b) => a.cena - b.cena);
console.log(wgCeny.map((p) => p.nazwa));

const wgNazwy = [...produkty].sort((a, b) => a.nazwa.localeCompare(b.nazwa, 'pl'));
console.log(wgNazwy.map((p) => p.nazwa));

const oryginal = [3, 1, 2];

const posortowane = oryginal.toSorted((a, b) => a - b);
console.log(oryginal, posortowane);   // oryginał bez zmian

const odwrocone = oryginal.toReversed();
console.log(oryginal, odwrocone);

const zmieniony = oryginal.with(0, 99); // kopia z podmienionym elementem
console.log(oryginal, zmieniony);

// kontrast: sort mutuje
const kopia = [...oryginal];
kopia.sort((a, b) => a - b);
console.log(kopia);

const produkty = [
  { nazwa: 'Monitor', cena: 899, kategoria: 'ekrany', dostepny: true },
  { nazwa: 'Mysz', cena: 89, kategoria: 'akcesoria', dostepny: true },
  { nazwa: 'Klawiatura', cena: 199, kategoria: 'akcesoria', dostepny: false },
  { nazwa: 'Podkładka', cena: 25, kategoria: 'akcesoria', dostepny: true },
];

// dostępne akcesoria, od najtańszego, jako napisy
const lista = produkty
  .filter((p) => p.dostepny && p.kategoria === 'akcesoria')
  .toSorted((a, b) => a.cena - b.cena)
  .map((p) => `${p.nazwa} (${p.cena} zł)`);
console.log(lista);

// łączna wartość dostępnych produktów
const wartosc = produkty
  .filter((p) => p.dostepny)
  .reduce((suma, p) => suma + p.cena, 0);
console.log(wartosc);

// kolejność ma znaczenie dla wydajności: najpierw filter (mniej elementów), potem map
const drogie = produkty.filter((p) => p.cena > 100).map((p) => p.nazwa);
console.log(drogie);