Kurs JavaScript i TypeScript · Moduł 2: Funkcje, tablice i obiekty

Tworzenie i manipulacja tablicami w JavaScript

16 min czytania ·
W tej lekcji9

Witaj ponownie w Parku Jurajskim! Dzisiaj będziemy zajmować się tablicami w JavaScript - strukturami danych, które są niezbędne do zarządzania kolekcjami obiektów, takich jak nasze gatunki dinozaurów, wyniki badań genetycznych czy dane z systemów monitorowania parku.

Czym są tablice?

Tablice to uporządkowane kolekcje elementów, które mogą przechowywać dane dowolnego typu. Można je porównać do szafek laboratoryjnych, gdzie każda szuflada (indeks tablicy) zawiera konkretną próbkę (element tablicy). Każdy element ma swój unikalny numer pozycji (indeks), który rozpoczyna się od 0.

Tworzenie tablic

W JavaScript istnieje kilka sposobów tworzenia tablic:

1. Literał tablicowy (najczęściej używany)

Najpopularniejszym sposobem jest użycie nawiasów kwadratowych []:

// Tablica gatunków dinozaurów w naszym parku
const dinosaurs = ["Tyrannosaurus", "Velociraptor", "Triceratops", "Brachiosaurus"];

// Tablica mieszanych typów danych (liczby, stringi, booleany)
const dinoData = ["Blue", 5, true, 120.5];

// Pusta tablica, do której będziemy dodawać elementy później
const dinoEnclosures = [];

2. Konstruktor Array

Możemy również użyć konstruktora Array():

// Tablica utworzona za pomocą konstruktora
const parkSectors = new Array("A", "B", "C", "D", "E");

// Tablica z predefiniowaną długością, ale bez wartości
const securityReadings = new Array(10); // Tworzy tablicę z 10 pustymi elementami

// Uwaga: jeśli przekażemy tylko jedną liczbę, tworzy to tablicę o tej długości
// Jeśli przekażemy wiele argumentów, tworzą one elementy tablicy
const confusingArray = new Array(3); // Tablica o długości 3: [empty x 3]
const normalArray = new Array(1, 2, 3); // Tablica z trzema elementami: [1, 2, 3]

3. Metoda Array.of() (ES6)

Aby uniknąć niejednoznaczności konstruktora Array(), można użyć Array.of():

// Zawsze tworzy tablicę z przekazanymi elementami
const weights = Array.of(5000); // [5000], a nie tablica długości 5000
const measurements = Array.of(1, 2, 3, 4, 5); // [1, 2, 3, 4, 5]

4. Metoda Array.from() (ES6)

Ta metoda tworzy tablicę z obiektów podobnych do tablicy (np. kolekcji DOM) lub iterowalnych (np. stringów):

// Tworzenie tablicy z iterowalnego obiektu (string)
const dinoLetters = Array.from("TREX"); // ["T", "R", "E", "X"]

// Tworzenie tablicy z mapowaniem
const dinoAges = Array.from([5, 7, 3, 10], age => age * 2); // [10, 14, 6, 20]

// Przykład z kolekcją DOM (w przeglądarce)
// const dinoElements = Array.from(document.querySelectorAll('.dinosaur'));

Dostęp do elementów tablicy

Elementy tablicy są indeksowane od 0, co oznacza, że pierwszy element ma indeks 0, drugi 1, itd.

const velociraptors = ["Blue", "Delta", "Echo", "Charlie"];

// Dostęp do pojedynczych elementów
console.log(velociraptors[0]); // "Blue"
console.log(velociraptors[2]); // "Echo"

// Modyfikacja elementu
velociraptors[1] = "New Delta";
console.log(velociraptors); // ["Blue", "New Delta", "Echo", "Charlie"]

// Dostęp do nieistniejącego elementu zwraca undefined
console.log(velociraptors[10]); // undefined

Długość tablicy

Właściwość length zwraca liczbę elementów w tablicy:

const dinosaurs = ["T-Rex", "Velociraptor", "Triceratops"];
console.log(dinosaurs.length); // 3

// Możemy również modyfikować długość tablicy
dinosaurs.length = 2;
console.log(dinosaurs); // ["T-Rex", "Velociraptor"] - Triceratops został usunięty

// Zwiększenie długości dodaje puste elementy
dinosaurs.length = 5;
console.log(dinosaurs); // ["T-Rex", "Velociraptor", empty x 3]

Podstawowe operacje na tablicach

Dodawanie elementów

Istnieje kilka sposobów dodawania elementów do tablicy:

1. Na końcu tablicy: push()

const dinosaurs = ["T-Rex", "Velociraptor"];

// Dodawanie na końcu
dinosaurs.push("Triceratops");
console.log(dinosaurs); // ["T-Rex", "Velociraptor", "Triceratops"]

// push może dodać wiele elementów naraz
dinosaurs.push("Brachiosaurus", "Stegosaurus");
console.log(dinosaurs); // ["T-Rex", "Velociraptor", "Triceratops", "Brachiosaurus", "Stegosaurus"]

// push zwraca nową długość tablicy
const newLength = dinosaurs.push("Ankylosaurus");
console.log(newLength); // 6

2. Na początku tablicy: unshift()

const dinosaurs = ["Velociraptor", "Triceratops"];

// Dodawanie na początku
dinosaurs.unshift("T-Rex");
console.log(dinosaurs); // ["T-Rex", "Velociraptor", "Triceratops"]

// unshift również może dodać wiele elementów naraz
dinosaurs.unshift("Spinosaurus", "Dilophosaurus");
console.log(dinosaurs); // ["Spinosaurus", "Dilophosaurus", "T-Rex", "Velociraptor", "Triceratops"]

// unshift także zwraca nową długość tablicy
const newLength = dinosaurs.unshift("Compsognathus");
console.log(newLength); // 6

3. Na konkretnej pozycji: splice()

const dinosaurs = ["T-Rex", "Velociraptor", "Stegosaurus"];

// Wstawianie elementu na pozycji 1 (jako drugi element)
// splice(pozycja, ile_usunąć, elementy_do_dodania...)
dinosaurs.splice(1, 0, "Triceratops");
console.log(dinosaurs); // ["T-Rex", "Triceratops", "Velociraptor", "Stegosaurus"]

// Zastępowanie elementu na pozycji 2
dinosaurs.splice(2, 1, "Brachiosaurus");
console.log(dinosaurs); // ["T-Rex", "Triceratops", "Brachiosaurus", "Stegosaurus"]

// Możemy dodać wiele elementów naraz
dinosaurs.splice(1, 0, "Ankylosaurus", "Dilophosaurus");
console.log(dinosaurs); // ["T-Rex", "Ankylosaurus", "Dilophosaurus", "Triceratops", "Brachiosaurus", "Stegosaurus"]

Usuwanie elementów

Podobnie jak w przypadku dodawania, istnieje kilka metod usuwania elementów:

1. Z końca tablicy: pop()

const dinosaurs = ["T-Rex", "Velociraptor", "Triceratops"];

// Usuwanie ostatniego elementu
const removedDino = dinosaurs.pop();
console.log(removedDino); // "Triceratops"
console.log(dinosaurs); // ["T-Rex", "Velociraptor"]

2. Z początku tablicy: shift()

const dinosaurs = ["T-Rex", "Velociraptor", "Triceratops"];

// Usuwanie pierwszego elementu
const removedDino = dinosaurs.shift();
console.log(removedDino); // "T-Rex"
console.log(dinosaurs); // ["Velociraptor", "Triceratops"]

3. Z konkretnej pozycji: splice()

const dinosaurs = ["T-Rex", "Velociraptor", "Triceratops", "Stegosaurus"];

// Usuwanie jednego elementu na pozycji 1
const removedDinos = dinosaurs.splice(1, 1);
console.log(removedDinos); // ["Velociraptor"]
console.log(dinosaurs); // ["T-Rex", "Triceratops", "Stegosaurus"]

// Usuwanie wielu elementów zaczynając od pozycji 1
const moreRemovedDinos = dinosaurs.splice(1, 2);
console.log(moreRemovedDinos); // ["Triceratops", "Stegosaurus"]
console.log(dinosaurs); // ["T-Rex"]

Znalezienie elementu w tablicy

1. indexOf() i lastIndexOf()

const dinosaurs = ["T-Rex", "Velociraptor", "Triceratops", "Velociraptor"];

// Znalezienie pierwszego wystąpienia
const firstIndex = dinosaurs.indexOf("Velociraptor");
console.log(firstIndex); // 1

// Znalezienie ostatniego wystąpienia
const lastIndex = dinosaurs.lastIndexOf("Velociraptor");
console.log(lastIndex); // 3

// Jeśli element nie istnieje, zwraca -1
const notFoundIndex = dinosaurs.indexOf("Spinosaurus");
console.log(notFoundIndex); // -1

2. includes() (ES6)

const dinosaurs = ["T-Rex", "Velociraptor", "Triceratops"];

// Sprawdzenie, czy element istnieje w tablicy
const hasVelociraptor = dinosaurs.includes("Velociraptor");
console.log(hasVelociraptor); // true

const hasSpinosaurus = dinosaurs.includes("Spinosaurus");
console.log(hasSpinosaurus); // false

3. find() i findIndex() (ES6)

Metody te są przydatne do wyszukiwania elementów złożonych (obiektów) na podstawie kryteriów:

// Tablica obiektów dinozaurów
const dinosaurData = [
  { name: "Rex", species: "Tyrannosaurus", age: 16, dangerous: true },
  { name: "Blue", species: "Velociraptor", age: 5, dangerous: true },
  { name: "Spike", species: "Stegosaurus", age: 10, dangerous: false },
  { name: "Trixie", species: "Triceratops", age: 18, dangerous: false }
];

// Znalezienie pierwszego dinozaura starszego niż 15 lat
const oldDino = dinosaurData.find(dino => dino.age > 15);
console.log(oldDino); // { name: "Rex", species: "Tyrannosaurus", age: 16, dangerous: true }

// Znalezienie indeksu pierwszego bezpiecznego dinozaura
const safeIndex = dinosaurData.findIndex(dino => !dino.dangerous);
console.log(safeIndex); // 2 (Spike)

Kopiowanie i łączenie tablic

1. Kopiowanie tablicy za pomocą slice()

const originalDinos = ["T-Rex", "Velociraptor", "Triceratops"];

// Tworzenie kopii całej tablicy
const dinosCopy = originalDinos.slice();
console.log(dinosCopy); // ["T-Rex", "Velociraptor", "Triceratops"]

// Kopiowanie części tablicy (od indeksu 1 do końca)
const partialCopy = originalDinos.slice(1);
console.log(partialCopy); // ["Velociraptor", "Triceratops"]

// Kopiowanie zakresu (od indeksu 0 do 1, bez 2)
const rangeCopy = originalDinos.slice(0, 2);
console.log(rangeCopy); // ["T-Rex", "Velociraptor"]

2. Łączenie tablic za pomocą concat()

const carnivores = ["T-Rex", "Velociraptor"];
const herbivores = ["Triceratops", "Brachiosaurus", "Stegosaurus"];

// Łączenie dwóch tablic
const allDinos = carnivores.concat(herbivores);
console.log(allDinos);
// ["T-Rex", "Velociraptor", "Triceratops", "Brachiosaurus", "Stegosaurus"]

// Można łączyć więcej tablic naraz
const smallDinos = ["Compsognathus"];
const allSpecies = carnivores.concat(herbivores, smallDinos);
console.log(allSpecies);
// ["T-Rex", "Velociraptor", "Triceratops", "Brachiosaurus", "Stegosaurus", "Compsognathus"]

3. Operator rozproszenia (spread) (ES6)

const carnivores = ["T-Rex", "Velociraptor"];
const herbivores = ["Triceratops", "Brachiosaurus"];

// Łączenie tablic za pomocą spread
const allDinos = [...carnivores, ...herbivores];
console.log(allDinos); // ["T-Rex", "Velociraptor", "Triceratops", "Brachiosaurus"]

// Można dodawać elementy w środku
const mixedCollection = [...carnivores, "Dilophosaurus", ...herbivores];
console.log(mixedCollection);
// ["T-Rex", "Velociraptor", "Dilophosaurus", "Triceratops", "Brachiosaurus"]

// Kopiowanie tablicy za pomocą spread
const dinosCopy = [...carnivores];
console.log(dinosCopy); // ["T-Rex", "Velociraptor"]

Przeszukiwanie i sortowanie tablic

1. Sortowanie tablicy: sort()

const dinosaurs = ["Velociraptor", "Tyrannosaurus", "Brachiosaurus", "Ankylosaurus"];

// Sortowanie alfabetyczne (domyślne)
dinosaurs.sort();
console.log(dinosaurs);
// ["Ankylosaurus", "Brachiosaurus", "Tyrannosaurus", "Velociraptor"]

// Sortowanie liczb (wymaga funkcji porównującej)
const dinoWeights = [5000, 500, 15000, 7000];

// Bez funkcji porównującej - nieprawidłowo sortuje liczby jako stringi
dinoWeights.sort();
console.log(dinoWeights); // [15000, 500, 5000, 7000] (niepoprawnie!)

// Z funkcją porównującą - poprawne sortowanie rosnąco
dinoWeights.sort((a, b) => a - b);
console.log(dinoWeights); // [500, 5000, 7000, 15000]

// Sortowanie malejąco
dinoWeights.sort((a, b) => b - a);
console.log(dinoWeights); // [15000, 7000, 5000, 500]

2. Sortowanie obiektów

const dinosaurData = [
  { name: "Rex", species: "Tyrannosaurus", age: 16 },
  { name: "Blue", species: "Velociraptor", age: 5 },
  { name: "Spike", species: "Stegosaurus", age: 10 },
  { name: "Trixie", species: "Triceratops", age: 18 }
];

// Sortowanie po wieku (rosnąco)
dinosaurData.sort((a, b) => a.age - b.age);
console.log(dinosaurData.map(dino => `${dino.name} (${dino.age})`));
// ["Blue (5)", "Spike (10)", "Rex (16)", "Trixie (18)"]

// Sortowanie po nazwie (alfabetycznie)
dinosaurData.sort((a, b) => a.name.localeCompare(b.name));
console.log(dinosaurData.map(dino => dino.name));
// ["Blue", "Rex", "Spike", "Trixie"]

3. Odwracanie kolejności: reverse()

const dinosaurs = ["T-Rex", "Velociraptor", "Triceratops", "Brachiosaurus"];

// Odwrócenie kolejności elementów
dinosaurs.reverse();
console.log(dinosaurs); // ["Brachiosaurus", "Triceratops", "Velociraptor", "T-Rex"]

Przekształcanie tablic

1. Konwersja na string: join()

const dinosaurs = ["T-Rex", "Velociraptor", "Triceratops"];

// Łączenie wszystkich elementów w string z domyślnym separatorem (przecinek)
const dinoString = dinosaurs.join();
console.log(dinoString); // "T-Rex,Velociraptor,Triceratops"

// Z niestandardowym separatorem
const dinoList = dinosaurs.join(" | ");
console.log(dinoList); // "T-Rex | Velociraptor | Triceratops"

// Bez separatora
const dinoNoSeparator = dinosaurs.join("");
console.log(dinoNoSeparator); // "T-RexVelociraptorTriceratops"

2. Konwersja string na tablicę: split()

const dinoString = "T-Rex,Velociraptor,Triceratops";

// Rozdzielenie stringa na tablicę
const dinosaurs = dinoString.split(",");
console.log(dinosaurs); // ["T-Rex", "Velociraptor", "Triceratops"]

// Rozdzielenie po każdym znaku
const letters = "TREX".split("");
console.log(letters); // ["T", "R", "E", "X"]

Praktyczne przykłady pracy z tablicami

Przykład 1: System inwentaryzacji dinozaurów

// System inwentaryzacji dinozaurów w Parku Jurajskim
const dinosaurInventory = {
  species: [],

  // Dodawanie nowego gatunku do inwentarza
  addSpecies: function(name, count, carnivore) {
    // Sprawdzenie czy gatunek już istnieje
    const existingIndex = this.species.findIndex(s => s.name === name);

    if (existingIndex >= 0) {
      // Aktualizacja istniejącego gatunku
      this.species[existingIndex].count += count;
      console.log(`Zaktualizowano populację ${name}: ${this.species[existingIndex].count}`);
    } else {
      // Dodanie nowego gatunku
      this.species.push({
        name,
        count,
        carnivore,
        addDate: new Date().toISOString().split('T')[0]
      });
      console.log(`Dodano nowy gatunek: ${name} (liczba osobników: ${count})`);
    }

    return this;
  },

  // Usuwanie dinozaurów (np. w wyniku śmierci lub transferu)
  removeSpecimens: function(name, count, reason) {
    const index = this.species.findIndex(s => s.name === name);

    if (index === -1) {
      console.log(`Gatunek ${name} nie istnieje w inwentarzu.`);
      return false;
    }

    if (this.species[index].count < count) {
      console.log(`Błąd: Próbujesz usunąć więcej osobników (${count}) niż istnieje (${this.species[index].count}).`);
      return false;
    }

    this.species[index].count -= count;
    console.log(`Usunięto ${count} osobników gatunku ${name}. Powód: ${reason}.`);
    console.log(`Pozostało: ${this.species[index].count} osobników.`);

    // Jeśli nie ma już żadnych osobników, usuń gatunek z inwentarza
    if (this.species[index].count === 0) {
      const removed = this.species.splice(index, 1)[0];
      console.log(`Gatunek ${removed.name} został całkowicie usunięty z inwentarza.`);
    }

    return true;
  },

  // Generowanie podsumowania inwentarza
  generateSummary: function() {
    console.log("=== PODSUMOWANIE INWENTARZA DINOZAURÓW ===");

    if (this.species.length === 0) {
      console.log("Brak dinozaurów w inwentarzu.");
      return;
    }

    // Sortowanie gatunków według liczebności (malejąco)
    const sortedSpecies = [...this.species].sort((a, b) => b.count - a.count);

    // Liczba gatunków i osobników
    const totalSpecies = sortedSpecies.length;
    const totalSpecimens = sortedSpecies.reduce((sum, species) => sum + species.count, 0);
    console.log(`Liczba gatunków: ${totalSpecies}`);
    console.log(`Łączna liczba osobników: ${totalSpecimens}`);

    // Podział na mięsożerne i roślinożerne
    const carnivores = sortedSpecies.filter(s => s.carnivore);
    const herbivores = sortedSpecies.filter(s => !s.carnivore);

    console.log(`Gatunki mięsożerne: ${carnivores.length}`);
    console.log(`Gatunki roślinożerne: ${herbivores.length}`);

    // Najbardziej liczne gatunki
    if (sortedSpecies.length > 0) {
      console.log("\nNajwiększa populacja:");
      sortedSpecies.slice(0, 3).forEach((species, i) => {
        console.log(`${i+1}. ${species.name}: ${species.count} osobników`);
      });
    }

    // Tabela wszystkich gatunków
    console.log("\nSzczegółowy wykaz gatunków:");
    console.log("Nazwa | Liczebność | Typ | Data dodania");
    console.log("------|------------|-----|-------------");
    sortedSpecies.forEach(species => {
      const type = species.carnivore ? "Mięsożerny" : "Roślinożerny";
      console.log(`${species.name.padEnd(6)} | ${String(species.count).padEnd(10)} | ${type.padEnd(4)} | ${species.addDate}`);
    });
  }
};

// Testowanie systemu inwentaryzacji
dinosaurInventory.addSpecies("T-Rex", 3, true);
dinosaurInventory.addSpecies("Velociraptor", 12, true);
dinosaurInventory.addSpecies("Triceratops", 8, false);
dinosaurInventory.addSpecies("Brachiosaurus", 5, false);
dinosaurInventory.addSpecies("Gallimimus", 20, false);

// Aktualizacja istniejących gatunków
dinosaurInventory.addSpecies("Velociraptor", 4, true); // Dodanie 4 nowych Velociraptorów

// Usuwanie osobników
dinosaurInventory.removeSpecimens("T-Rex", 1, "Śmierć ze starości");
dinosaurInventory.removeSpecimens("Gallimimus", 5, "Transfer do innego parku");

// Generowanie podsumowania
dinosaurInventory.generateSummary();

Przykład 2: Analiza danych genetycznych

// Przykładowe dane genetyczne (uproszczone) jako tablica
const geneticData = [
  { id: "TRX01", species: "Tyrannosaurus", sequenceMatch: 0.85, viability: "High", complete: true },
  { id: "VLR02", species: "Velociraptor", sequenceMatch: 0.93, viability: "Medium", complete: true },
  { id: "TRC04", species: "Triceratops", sequenceMatch: 0.79, viability: "Low", complete: false },
  { id: "BRCH1", species: "Brachiosaurus", sequenceMatch: 0.81, viability: "Medium", complete: true },
  { id: "STEG7", species: "Stegosaurus", sequenceMatch: 0.76, viability: "Low", complete: false },
  { id: "ANKL5", species: "Ankylosaurus", sequenceMatch: 0.88, viability: "High", complete: true },
  { id: "DILO3", species: "Dilophosaurus", sequenceMatch: 0.91, viability: "Medium", complete: false },
  { id: "PTRD9", species: "Pteranodon", sequenceMatch: 0.72, viability: "Low", complete: false }
];

// Funkcje analizy danych
function analyzeGeneticData(data) {
  console.log("=== ANALIZA DANYCH GENETYCZNYCH ===");

  // 1. Ile sekwencji jest kompletnych?
  const completeSequences = data.filter(seq => seq.complete);
  console.log(`Kompletne sekwencje: ${completeSequences.length} z ${data.length} (${((completeSequences.length / data.length) * 100).toFixed(1)}%)`);

  // 2. Średni współczynnik dopasowania sekwencji
  const averageMatch = data.reduce((sum, seq) => sum + seq.sequenceMatch, 0) / data.length;
  console.log(`Średnie dopasowanie sekwencji: ${(averageMatch * 100).toFixed(1)}%`);

  // 3. Wyodrębnij najlepsze i najgorsze dopasowania
  const sortedByMatch = [...data].sort((a, b) => b.sequenceMatch - a.sequenceMatch);

  console.log("\nNajlepsze dopasowania sekwencji:");
  sortedByMatch.slice(0, 3).forEach((seq, i) => {
    console.log(`${i+1}. ${seq.species} (ID: ${seq.id}): ${(seq.sequenceMatch * 100).toFixed(1)}%`);
  });

  console.log("\nNajgorsze dopasowania sekwencji:");
  sortedByMatch.slice(-3).reverse().forEach((seq, i) => {
    console.log(`${i+1}. ${seq.species} (ID: ${seq.id}): ${(seq.sequenceMatch * 100).toFixed(1)}%`);
  });

  // 4. Grupowanie według zdolności do życia (viability)
  const viabilityGroups = data.reduce((groups, seq) => {
    if (!groups[seq.viability]) {
      groups[seq.viability] = [];
    }
    groups[seq.viability].push(seq);
    return groups;
  }, {});

  console.log("\nGrupowanie według zdolności do życia:");
  Object.entries(viabilityGroups).forEach(([viability, sequences]) => {
    console.log(`${viability}: ${sequences.length} sekwencji`);
    sequences.forEach(seq => {
      console.log(`  - ${seq.species} (ID: ${seq.id})`);
    });
  });

  // 5. Filtry sekwencji priorytetowych do dalszych badań
  const highPrioritySequences = data.filter(seq =>
    seq.sequenceMatch > 0.85 && !seq.complete
  );

  console.log("\nSekwencje priorytetowe do dokończenia:");
  if (highPrioritySequences.length > 0) {
    highPrioritySequences.forEach(seq => {
      console.log(`- ${seq.species} (ID: ${seq.id}): dopasowanie ${(seq.sequenceMatch * 100).toFixed(1)}%, zdolność do życia: ${seq.viability}`);
    });
  } else {
    console.log("Brak sekwencji priorytetowych.");
  }

  return {
    totalSequences: data.length,
    completeSequences: completeSequences.length,
    averageMatch,
    bestMatch: sortedByMatch[0],
    worstMatch: sortedByMatch[sortedByMatch.length - 1],
    viabilityDistribution: Object.fromEntries(
      Object.entries(viabilityGroups).map(([key, val]) => [key, val.length])
    ),
    highPrioritySequences
  };
}

// Wykonanie analizy
const analysisResults = analyzeGeneticData(geneticData);
console.log("\nWynik analizy jako obiekt:", analysisResults);

// Filtrowanie i manipulacja danych
console.log("\n=== MANIPULACJA DANYMI ===");

// 1. Stworzenie nowej tablicy tylko z wybranymi polami
const simplifiedData = geneticData.map(seq => ({
  id: seq.id,
  species: seq.species,
  match: seq.sequenceMatch
}));
console.log("Uproszczone dane:", simplifiedData);

// 2. Filtrowanie do pokazania tylko kompletnych sekwencji z wysokim dopasowaniem
const highQualitySequences = geneticData.filter(seq =>
  seq.complete && seq.sequenceMatch > 0.8
);
console.log("Sekwencje wysokiej jakości:", highQualitySequences);

// 3. Sortowanie według gatunku alfabetycznie
const sortedBySpecies = [...geneticData].sort((a, b) =>
  a.species.localeCompare(b.species)
);
console.log("Sortowanie alfabetycznie według gatunku:",
  sortedBySpecies.map(seq => seq.species)
);

// 4. Łączenie z inną tablicą (nowe dane)
const newGeneticData = [
  { id: "PCHY1", species: "Pachycephalosaurus", sequenceMatch: 0.83, viability: "Medium", complete: true },
  { id: "SPNO5", species: "Spinosaurus", sequenceMatch: 0.89, viability: "High", complete: false }
];

const combinedData = [...geneticData, ...newGeneticData];
console.log(`Połączone dane: ${combinedData.length} sekwencji`);

// 5. Łączenie w string do raportu CSV
const csvHeader = "ID,Gatunek,Dopasowanie,Żywotność,Kompletne";
const csvRows = combinedData.map(seq =>
  `${seq.id},${seq.species},${seq.sequenceMatch},${seq.viability},${seq.complete}`
);
const csvReport = [csvHeader, ...csvRows].join('\n');
console.log("Raport CSV:");
console.log(csvReport);

Zaawansowane metody tablicowe (ES6+)

Nowoczesny JavaScript dostarcza wielu potężnych metod do pracy z tablicami, które znacznie upraszczają przetwarzanie danych.

1. map() - transformacja elementów

Metoda map() tworzy nową tablicę przez transformację każdego elementu oryginalnej tablicy:

const dinosaurs = [
  { name: "Rex", species: "Tyrannosaurus" },
  { name: "Blue", species: "Velociraptor" },
  { name: "Spike", species: "Stegosaurus" }
];

// Pobranie tylko imion
const names = dinosaurs.map(dino => dino.name);
console.log(names); // ["Rex", "Blue", "Spike"]

// Tworzenie nowych obiektów
const dinoLabels = dinosaurs.map(dino => ({
  label: `${dino.name} (${dino.species})`,
  id: dino.name.toLowerCase()
}));
console.log(dinoLabels);
// [
//   { label: "Rex (Tyrannosaurus)", id: "rex" },
//   { label: "Blue (Velociraptor)", id: "blue" },
//   { label: "Spike (Stegosaurus)", id: "spike" }
// ]

2. filter() - filtrowanie elementów

Metoda filter() tworzy nową tablicę zawierającą tylko elementy, które spełniają określone kryterium:

const dinosaurs = [
  { name: "Rex", species: "Tyrannosaurus", carnivore: true, weight: 7000 },
  { name: "Blue", species: "Velociraptor", carnivore: true, weight: 100 },
  { name: "Spike", species: "Stegosaurus", carnivore: false, weight: 5000 },
  { name: "Trixie", species: "Triceratops", carnivore: false, weight: 8000 }
];

// Filtrowanie tylko drapieżników
const carnivores = dinosaurs.filter(dino => dino.carnivore);
console.log(carnivores.map(dino => dino.name)); // ["Rex", "Blue"]

// Filtrowanie ciężkich dinozaurów
const heavyDinos = dinosaurs.filter(dino => dino.weight > 1000);
console.log(heavyDinos.map(dino => dino.name)); // ["Rex", "Spike", "Trixie"]

// Łączenie warunków
const heavyCarnivores = dinosaurs.filter(dino => dino.carnivore && dino.weight > 1000);
console.log(heavyCarnivores.map(dino => dino.name)); // ["Rex"]

3. reduce() - agregacja elementów

Metoda reduce() redukuje tablicę do pojedynczej wartości, przechodząc przez wszystkie elementy:

const dinosaurs = [
  { name: "Rex", species: "Tyrannosaurus", weight: 7000 },
  { name: "Blue", species: "Velociraptor", weight: 100 },
  { name: "Spike", species: "Stegosaurus", weight: 5000 },
  { name: "Trixie", species: "Triceratops", weight: 8000 }
];

// Obliczanie łącznej wagi
const totalWeight = dinosaurs.reduce((sum, dino) => sum + dino.weight, 0);
console.log(`Łączna waga dinozaurów: ${totalWeight} kg`); // 20100 kg

// Znajdowanie najcięższego dinozaura
const heaviestDino = dinosaurs.reduce(
  (heaviest, dino) => dino.weight > heaviest.weight ? dino : heaviest,
  dinosaurs[0]
);
console.log(`Najcięższy dinozaur: ${heaviestDino.name} (${heaviestDino.weight} kg)`);
// Najcięższy dinozaur: Trixie (8000 kg)

// Tworzenie obiektu mapującego gatunki na dinozaury
const dinosBySpecies = dinosaurs.reduce((acc, dino) => {
  acc[dino.species] = dino;
  return acc;
}, {});

console.log(dinosBySpecies.Velociraptor.name); // "Blue"

4. some() i every() - testowanie elementów

Metody te sprawdzają, czy niektóre/wszystkie elementy spełniają określone kryterium:

const dinosaurs = [
  { name: "Rex", species: "Tyrannosaurus", dangerous: true, contained: true },
  { name: "Blue", species: "Velociraptor", dangerous: true, contained: false },
  { name: "Spike", species: "Stegosaurus", dangerous: false, contained: true }
];

// Sprawdzenie, czy jakikolwiek dinozaur jest niebezpieczny
const anyDangerous = dinosaurs.some(dino => dino.dangerous);
console.log("Czy jakiś dinozaur jest niebezpieczny?", anyDangerous); // true

// Sprawdzenie, czy wszystkie dinozaury są bezpiecznie zamknięte
const allContained = dinosaurs.every(dino => dino.contained);
console.log("Czy wszystkie dinozaury są bezpiecznie zamknięte?", allContained); // false

// Sprawdzenie, czy wszystkie niebezpieczne dinozaury są zamknięte
const allDangerousContained = dinosaurs
  .filter(dino => dino.dangerous)
  .every(dino => dino.contained);
console.log("Czy wszystkie niebezpieczne dinozaury są zamknięte?", allDangerousContained); // false

5. flat() i flatMap() (ES2019)

Metody te spłaszczają zagnieżdżone tablice:

// Zagnieżdżona tablica dinozaurów według zagród
const enclosures = [
  ["Rex", "Rexy"], // Zagroda T-Rexów
  ["Blue", "Delta", "Echo"], // Zagroda Velociraptorów
  ["Spike", "Spikey"], // Zagroda Stegozaurów
  [] // Pusta zagroda
];

// Spłaszczanie do pojedynczej tablicy
const allDinos = enclosures.flat();
console.log(allDinos); // ["Rex", "Rexy", "Blue", "Delta", "Echo", "Spike", "Spikey"]

// Bardziej złożony przykład z flatMap
const enclosureData = [
  { type: "T-Rex", dinosaurs: ["Rex", "Rexy"] },
  { type: "Velociraptor", dinosaurs: ["Blue", "Delta", "Echo"] },
  { type: "Stegosaurus", dinosaurs: ["Spike", "Spikey"] }
];

// Mapowanie i spłaszczanie w jednym kroku
const dinosaursWithTypes = enclosureData.flatMap(enclosure =>
  enclosure.dinosaurs.map(dino => `${dino} (${enclosure.type})`)
);

console.log(dinosaursWithTypes);
// [
//   "Rex (T-Rex)",
//   "Rexy (T-Rex)",
//   "Blue (Velociraptor)",
//   "Delta (Velociraptor)",
//   "Echo (Velociraptor)",
//   "Spike (Stegosaurus)",
//   "Spikey (Stegosaurus)"
// ]

Podsumowanie

Tablice są jedną z najpotężniejszych struktur danych w JavaScript, pozwalając na przechowywanie, organizowanie i manipulowanie kolekcjami elementów. W tej lekcji poznaliśmy:

  1. Różne sposoby tworzenia tablic: literały tablicowe, konstruktor Array(), metody Array.of() i Array.from()
  2. Podstawowe operacje na tablicach: dodawanie elementów (push, unshift, splice), usuwanie elementów (pop, shift, splice), dostęp do elementów
  3. Metody wyszukiwania: indexOf, includes, find, findIndex
  4. Metody kopiowania i łączenia: slice, concat, operator spread (...)
  5. Metody sortowania i porównywania: sort, reverse
  6. Metody przekształcania: join (na string), split (ze stringa)
  7. Zaawansowane metody przetwarzania: map, filter, reduce, some, every, flat, flatMap

Umiejętność efektywnego wykorzystania tablic jest niezbędna w codziennej pracy z JavaScript, szczególnie gdy zarządzamy dużymi zbiorami danych, takimi jak nasz wirtualny inwentarz dinozaurów.

W następnej lekcji poznasz metody, które dodają i usuwają elementy tablicy.

Kod do tej lekcji: index.js
// Tablice - Park Jurajski
console.log("Laboratorium Tablic JavaScript");
console.log("Zarządzanie kolekcjami dinozaurów\n");

// ===========================================
// 1. TWORZENIE TABLIC
// ===========================================
console.log("=== 1. Tworzenie tablic ===");

// Sposób 1: Literał tablicowy (najczęstszy)
const dinosaurs = ["T-Rex", "Velociraptor", "Triceratops"];
console.log("Literał:", dinosaurs);

// Sposób 2: Konstruktor Array
const carnivores = new Array("T-Rex", "Velociraptor", "Spinosaurus");
console.log("Konstruktor:", carnivores);

// Sposób 3: Array.of()
const herbivores = Array.of("Triceratops", "Stegosaurus", "Brachiosaurus");
console.log("Array.of():", herbivores);

// Sposób 4: Array.from()
const dinoNames = "TRex";
const lettersArray = Array.from(dinoNames);
console.log("Array.from():", lettersArray);

// Pusta tablica
const emptyArray = [];
console.log("Pusta:", emptyArray, "długość:", emptyArray.length);

// Tablica o określonym rozmiarze
const fixedSize = new Array(5);
console.log("Rozmiar 5:", fixedSize, "długość:", fixedSize.length);

// ===========================================
// 2. DOSTĘP DO ELEMENTÓW
// ===========================================
console.log("\n=== 2. Dostęp do elementów ===");

const jurassicDinos = ["T-Rex", "Velociraptor", "Triceratops", "Stegosaurus", "Brachiosaurus"];

console.log("\nDostęp przez indeks:");
console.log("Pierwszy [0]:", jurassicDinos[0]);
console.log("Drugi [1]:", jurassicDinos[1]);
console.log("Ostatni [-1 = length-1]:", jurassicDinos[jurassicDinos.length - 1]);

// Dostęp do nieistniejącego indeksu
console.log("Nieistniejący [10]:", jurassicDinos[10]); // undefined

// Długość tablicy
console.log("\nDługość tablicy:", jurassicDinos.length);

// ===========================================
// 3. DODAWANIE ELEMENTÓW
// ===========================================
console.log("\n=== 3. Dodawanie elementów ===");

const parkDinos = ["T-Rex", "Velociraptor"];
console.log("\nPoczątkowa lista:", parkDinos);

// push() - dodaj na końcu
parkDinos.push("Triceratops");
console.log("push('Triceratops'):", parkDinos);

parkDinos.push("Stegosaurus", "Brachiosaurus");
console.log("push(2 elementy):", parkDinos);

// unshift() - dodaj na początku
parkDinos.unshift("Dilophosaurus");
console.log("unshift('Dilophosaurus'):", parkDinos);

// Bezpośrednie przypisanie do indeksu
parkDinos[10] = "Pteranodon";
console.log("parkDinos[10]:", parkDinos);
console.log("Długość:", parkDinos.length); // 11 (są puste miejsca!)

// ===========================================
// 4. USUWANIE ELEMENTÓW
// ===========================================
console.log("\n=== 4. Usuwanie elementów ===");

const removeDinos = ["T-Rex", "Velociraptor", "Triceratops", "Stegosaurus"];
console.log("\nPoczątkowa lista:", removeDinos);

// pop() - usuń ostatni
const removed1 = removeDinos.pop();
console.log(`pop(): usunięto '${removed1}'`, removeDinos);

// shift() - usuń pierwszy
const removed2 = removeDinos.shift();
console.log(`shift(): usunięto '${removed2}'`, removeDinos);

// delete - tworzy "dziurę" (NIE ZALECANE!)
delete removeDinos[0];
console.log("delete removeDinos[0]:", removeDinos);
console.log("Długość nadal:", removeDinos.length);

// splice() - usuwanie z dowolnego miejsca
const spliceDinos = ["T-Rex", "Velociraptor", "Triceratops", "Stegosaurus", "Brachiosaurus"];
const removed3 = spliceDinos.splice(2, 1); // Usuń 1 element od indeksu 2
console.log(`\nsplice(2, 1): usunięto ${removed3}`, spliceDinos);

// ===========================================
// 5. MODYFIKOWANIE ELEMENTÓW
// ===========================================
console.log("\n=== 5. Modyfikowanie elementów ===");

const modifyDinos = ["T-Rex", "Velociraptor", "Triceratops"];
console.log("\nOryginalna:", modifyDinos);

// Zmiana pojedynczego elementu
modifyDinos[1] = "Blue (Velociraptor)";
console.log("Po zmianie [1]:", modifyDinos);

// splice() do zamiany
modifyDinos.splice(2, 1, "Trike (Triceratops)", "Stego (Stegosaurus)");
console.log("splice(2, 1, ...2 nowe):", modifyDinos);

// ===========================================
// 6. KOPIOWANIE TABLIC
// ===========================================
console.log("\n=== 6. Kopiowanie tablic ===");

const original = ["T-Rex", "Velociraptor", "Triceratops"];

// Płytka kopia - spread operator
const copy1 = [...original];
console.log("\nSpread [...original]:", copy1);

// Płytka kopia - slice()
const copy2 = original.slice();
console.log("slice():", copy2);

// Płytka kopia - Array.from()
const copy3 = Array.from(original);
console.log("Array.from():", copy3);

// Przypisanie (NIE kopia!)
const reference = original;
reference.push("Stegosaurus");
console.log("\nReferencja (NIE kopia):");
console.log("original:", original); // Też zmieniony!
console.log("reference:", reference);

// ===========================================
// 7. ŁĄCZENIE TABLIC
// ===========================================
console.log("\n=== 7. Łączenie tablic ===");

const carnivoreList = ["T-Rex", "Velociraptor", "Spinosaurus"];
const herbivoreList = ["Triceratops", "Stegosaurus", "Brachiosaurus"];

// concat()
const allDinos1 = carnivoreList.concat(herbivoreList);
console.log("\nconcat():", allDinos1);

// Spread operator
const allDinos2 = [...carnivoreList, ...herbivoreList];
console.log("Spread:", allDinos2);

// Łączenie z dodatkowymi elementami
const allDinos3 = [...carnivoreList, "Dilophosaurus", ...herbivoreList];
console.log("Spread + dodatkowe:", allDinos3);

// ===========================================
// 8. WYCINANIE I DZIELENIE
// ===========================================
console.log("\n=== 8. Wycinanie tablic ===");

const allSpecies = ["T-Rex", "Velociraptor", "Triceratops", "Stegosaurus", "Brachiosaurus"];

// slice(start, end) - nie modyfikuje oryginału
const firstThree = allSpecies.slice(0, 3);
console.log("\nslice(0, 3):", firstThree);
console.log("Oryginał:", allSpecies); // Niezmieniony

const lastTwo = allSpecies.slice(-2);
console.log("slice(-2) - ostatnie 2:", lastTwo);

const middle = allSpecies.slice(1, 4);
console.log("slice(1, 4) - środek:", middle);

// splice(start, deleteCount, ...items) - modyfikuje oryginał
const splicedArray = ["T-Rex", "Velociraptor", "Triceratops", "Stegosaurus"];
const removedItems = splicedArray.splice(1, 2, "Blue", "Charlie");
console.log("\nsplice(1, 2, 'Blue', 'Charlie'):");
console.log("Usunięte:", removedItems);
console.log("Zmodyfikowana:", splicedArray);

// ===========================================
// 9. WYSZUKIWANIE W TABLICACH
// ===========================================
console.log("\n=== 9. Wyszukiwanie ===");

const searchDinos = ["T-Rex", "Velociraptor", "Triceratops", "Velociraptor", "Stegosaurus"];

// indexOf() - pierwszy indeks
console.log("\nindexOf('Velociraptor'):", searchDinos.indexOf("Velociraptor"));
console.log("indexOf('Brachiosaurus'):", searchDinos.indexOf("Brachiosaurus")); // -1 (nie znaleziono)

// lastIndexOf() - ostatni indeks
console.log("lastIndexOf('Velociraptor'):", searchDinos.lastIndexOf("Velociraptor"));

// includes() - czy zawiera
console.log("\nincludes('T-Rex'):", searchDinos.includes("T-Rex"));
console.log("includes('Pteranodon'):", searchDinos.includes("Pteranodon"));

// find() - pierwszy element spełniający warunek
const longName = searchDinos.find(dino => dino.length > 10);
console.log("\nfind(dino => dino.length > 10):", longName);

// findIndex() - indeks pierwszego elementu
const longNameIndex = searchDinos.findIndex(dino => dino.length > 10);
console.log("findIndex(dino => dino.length > 10):", longNameIndex);

// ===========================================
// 10. ODWRACANIE I SORTOWANIE
// ===========================================
console.log("\n=== 10. Odwracanie i sortowanie ===");

const sortDinos = ["Triceratops", "Velociraptor", "Stegosaurus", "T-Rex", "Brachiosaurus"];
console.log("\nOryginalna:", sortDinos);

// reverse() - odwraca kolejność (modyfikuje oryginał!)
const reversed = [...sortDinos].reverse(); // Kopia, żeby nie zmieniać oryginału
console.log("reverse():", reversed);

// sort() - sortuje alfabetycznie (modyfikuje oryginał!)
const sorted = [...sortDinos].sort();
console.log("sort():", sorted);

// Sortowanie niestandardowe
const weights = [8000, 80, 9000, 50000, 5000];
console.log("\nWagi:", weights);

const sortedWeights = [...weights].sort((a, b) => a - b);
console.log("sort() rosnąco:", sortedWeights);

const sortedDesc = [...weights].sort((a, b) => b - a);
console.log("sort() malejąco:", sortedDesc);

// ===========================================
// 11. PRZYKŁAD KOMPLEKSOWY
// ===========================================
console.log("\n=== 11. System inwentaryzacji - przykład kompleksowy ===");

class DinosaurInventory {
  constructor() {
    this.dinosaurs = [];
  }

  add(name, species, sector, health = 100) {
    const dino = { id: this.dinosaurs.length + 1, name, species, sector, health };
    this.dinosaurs.push(dino);
    console.log(`Dodano: ${name} (${species}) do sektora ${sector}`);
  }

  remove(name) {
    const index = this.dinosaurs.findIndex(d => d.name === name);
    if (index !== -1) {
      const removed = this.dinosaurs.splice(index, 1)[0];
      console.log(`Usunięto: ${removed.name}`);
    } else {
      console.log(`Nie znaleziono: ${name}`);
    }
  }

  findBySector(sector) {
    return this.dinosaurs.filter(d => d.sector === sector);
  }

  findBySpecies(species) {
    return this.dinosaurs.filter(d => d.species === species);
  }

  getHealthy() {
    return this.dinosaurs.filter(d => d.health >= 80);
  }

  getUnhealthy() {
    return this.dinosaurs.filter(d => d.health < 80);
  }

  sortByName() {
    return [...this.dinosaurs].sort((a, b) => a.name.localeCompare(b.name));
  }

  sortByHealth() {
    return [...this.dinosaurs].sort((a, b) => b.health - a.health);
  }

  displayAll() {
    console.log(`\nINWENTARYZACJA - Łącznie: ${this.dinosaurs.length}`);
    console.log("=".repeat(60));
    this.dinosaurs.forEach((dino, i) => {
      console.log(`${i + 1}. ${dino.name} (${dino.species}) - Sektor ${dino.sector} - Zdrowie: ${dino.health}%`);
    });
  }

  displayReport() {
    console.log("\nRAPORT SZCZEGÓŁOWY");
    console.log("=".repeat(60));

    const sectors = [...new Set(this.dinosaurs.map(d => d.sector))].sort();
    sectors.forEach(sector => {
      const inSector = this.findBySector(sector);
      console.log(`\nSektor ${sector} (${inSector.length} dinozaurów):`);
      inSector.forEach(dino => {
        console.log(`  - ${dino.name} (${dino.species}) - ${dino.health}%`);
      });
    });

    const healthy = this.getHealthy();
    const unhealthy = this.getUnhealthy();

    console.log(`\nZdrowe (${healthy.length}): ${healthy.map(d => d.name).join(", ")}`);
    if (unhealthy.length > 0) {
      console.log(`Wymagają uwagi (${unhealthy.length}): ${unhealthy.map(d => d.name).join(", ")}`);
    }
  }
}

// Demonstracja systemu
const inventory = new DinosaurInventory();

inventory.add("Rexy", "Tyrannosaurus Rex", "A", 95);
inventory.add("Blue", "Velociraptor", "B", 100);
inventory.add("Charlie", "Velociraptor", "B", 85);
inventory.add("Trike", "Triceratops", "C", 70);
inventory.add("Stego", "Stegosaurus", "C", 92);
inventory.add("Brachio", "Brachiosaurus", "D", 88);

inventory.displayAll();
inventory.displayReport();

console.log("\nSortowanie po nazwie:");
inventory.sortByName().forEach((d, i) => {
  console.log(`  ${i + 1}. ${d.name}`);
});

console.log("\nSortowanie po zdrowiu:");
inventory.sortByHealth().forEach((d, i) => {
  console.log(`  ${i + 1}. ${d.name} - ${d.health}%`);
});

inventory.remove("Charlie");
inventory.displayAll();

console.log("\nGratulacje! Opanowałeś tablice w JavaScript!");

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Zadania praktyczne w grze

  • Układanie w pionie

    Uporządkuj etapy dodawania nowego gatunku dinozaura do tablicy w JavaScript:

  1. Ułóż w kolejnościPodstawy tablic - etapy dodawania elementu

Przydatne artykuły