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

Parametry i argumenty funkcji w JavaScript

9 min czytania ·
W tej lekcji7

Witaj ponownie w Parku Jurajskim! W module 1 poznaliśmy podstawy funkcji w JavaScript. Teraz zagłębimy się w to, jak funkcje mogą przyjmować dane i pracować z nimi - co jest kluczowe dla tworzenia elastycznych i wydajnych systemów zarządzania parkiem.

Różnica między parametrami a argumentami

Choć terminy "parametry" i "argumenty" są często używane zamiennie, istnieje między nimi subtelna różnica:

  • Parametry to zmienne zdefiniowane w deklaracji funkcji
  • Argumenty to rzeczywiste wartości przekazywane do funkcji podczas jej wywołania
// name i species to parametry
function addDinosaur(name, species) {
  console.log(`Dodawanie nowego dinozaura: ${name} (${species})`);
  // Kod dodający dinozaura do systemu
}

// "Blue" i "Velociraptor" to argumenty
addDinosaur("Blue", "Velociraptor");

Parametry podstawowe

JavaScript oferuje kilka sposobów pracy z parametrami funkcji:

1. Parametry obowiązkowe i opcjonalne

W JavaScript wszystkie parametry są technicznie opcjonalne, ale możemy zaprojektować funkcje, które traktują niektóre parametry jako obowiązkowe:

function feedDinosaur(dinoName, foodType) {
  // Sprawdzenie czy parametry zostały podane
  if (dinoName === undefined) {
    throw new Error("Musisz podać nazwę dinozaura!");
  }

  // foodType jest opcjonalny, używamy wartości domyślnej jeśli nie został podany
  const food = foodType || "mięso";

  console.log(`Karmienie ${dinoName}, pokarm: ${food}`);
  return `${dinoName} został nakarmiony`;
}

// Wywołania
feedDinosaur("Rex", "żywe bydło"); // "Karmienie Rex, pokarm: żywe bydło"
feedDinosaur("Blue"); // "Karmienie Blue, pokarm: mięso"
// feedDinosaur(); // Error: Musisz podać nazwę dinozaura!

2. Parametry domyślne (ES6+)

Od ES6 (ES2015), JavaScript obsługuje parametry domyślne, które upraszczają definiowanie wartości domyślnych:

function scheduleFeeding(dinoName, foodType = "mięso", time = "12:00") {
  console.log(`Zaplanowano karmienie ${dinoName}, pokarm: ${foodType}, godzina: ${time}`);
  return {
    dino: dinoName,
    food: foodType,
    scheduledTime: time
  };
}

// Wywołania
scheduleFeeding("Triceratops", "rośliny", "10:30");
// "Zaplanowano karmienie Triceratops, pokarm: rośliny, godzina: 10:30"

scheduleFeeding("Raptor");
// "Zaplanowano karmienie Raptor, pokarm: mięso, godzina: 12:00"

scheduleFeeding("Rex", undefined, "15:45");
// "Zaplanowano karmienie Rex, pokarm: mięso, godzina: 15:45"

Parametry domyślne są oceniane w czasie wywołania funkcji, co oznacza, że możesz używać wyrażeń, a nawet innych parametrów:

function prepareEnclosure(dinoType, securityLevel = calculateSecurityLevel(dinoType), capacity = securityLevel * 2) {
  console.log(`Przygotowywanie zagrody dla ${dinoType}...`);
  console.log(`Poziom zabezpieczeń: ${securityLevel}`);
  console.log(`Pojemność: ${capacity} osobników`);
}

function calculateSecurityLevel(dinoType) {
  const dangerousSpecies = ["Tyrannosaurus", "Velociraptor", "Spinosaurus"];
  return dangerousSpecies.includes(dinoType) ? 5 : 3;
}

// Przygotowanie zagrody dla T-Rexa (wysoki poziom bezpieczeństwa)
prepareEnclosure("Tyrannosaurus");
// Poziom zabezpieczeń: 5, Pojemność: 10 osobników

// Przygotowanie zagrody dla Triceratopsa (standardowy poziom bezpieczeństwa)
prepareEnclosure("Triceratops");
// Poziom zabezpieczeń: 3, Pojemność: 6 osobników

// Przygotowanie niestandardowej zagrody
prepareEnclosure("Velociraptor", 6, 4);
// Poziom zabezpieczeń: 6, Pojemność: 4 osobników

Obsługa zmiennej liczby argumentów

W systemach tak złożonych jak Park Jurajski, czasem potrzebujemy funkcji, które mogą przyjmować zmienną liczbę argumentów.

1. Obiekt arguments

Każda zwykła funkcja (zadeklarowana słowem function) ma dostęp do specjalnego obiektu arguments, który zawiera wszystkie przekazane do niej argumenty. Funkcje strzałkowe nie mają własnego arguments:

function alertSecurityTeam() {
  console.log(`Wysyłanie alertu do ${arguments.length} członków zespołu bezpieczeństwa.`);

  for (let i = 0; i < arguments.length; i++) {
    console.log(`Powiadamianie: ${arguments[i]}`);
  }
}

// Możemy wywołać funkcję z dowolną liczbą argumentów
alertSecurityTeam("John Hammond", "Robert Muldoon", "Ellie Sattler");
// Wysyłanie alertu do 3 członków zespołu bezpieczeństwa.
// Powiadamianie: John Hammond
// Powiadamianie: Robert Muldoon
// Powiadamianie: Ellie Sattler

Obiekt arguments nie jest prawdziwą tablicą, ale podobnym do tablicy obiektem (array-like object). Można go konwertować do tablicy:

function logVisitors() {
  // Konwersja arguments na tablicę
  const visitorsArray = Array.from(arguments);
  // lub: const visitorsArray = [...arguments]; // (ES6+)

  console.log(`Zalogowano ${visitorsArray.length} gości.`);

  // Teraz możemy używać metod tablicowych
  visitorsArray.forEach((visitor, index) => {
    console.log(`Gość #${index + 1}: ${visitor}`);
  });
}

logVisitors("Ian Malcolm", "Alan Grant", "Dennis Nedry");
// Zalogowano 3 gości.
// Gość #1: Ian Malcolm
// Gość #2: Alan Grant
// Gość #3: Dennis Nedry

2. Parametr rest (ES6+)

Nowszy i bardziej elegancki sposób obsługi zmiennej liczby argumentów to parametr rest, wprowadzony w ES6:

function trackDinosaurs(...dinosaurs) {
  console.log(`Śledzenie ${dinosaurs.length} dinozaurów:`);

  dinosaurs.forEach((dino, index) => {
    console.log(`${index + 1}. Lokalizowanie: ${dino}`);
  });
}

trackDinosaurs("T-Rex", "Velociraptor", "Triceratops", "Brachiosaurus");
// Śledzenie 4 dinozaurów:
// 1. Lokalizowanie: T-Rex
// 2. Lokalizowanie: Velociraptor
// 3. Lokalizowanie: Triceratops
// 4. Lokalizowanie: Brachiosaurus

Parametr rest zbiera wszystkie pozostałe argumenty do tablicy. Musi być ostatnim parametrem w funkcji, ale może być poprzedzony zwykłymi parametrami:

function assignTasks(teamLead, date, ...teamMembers) {
  console.log(`Zadania na ${date} dla zespołu prowadzonego przez ${teamLead}:`);

  teamMembers.forEach(member => {
    console.log(`- ${member}: ${generateRandomTask()}`);
  });
}

function generateRandomTask() {
  const tasks = [
    "Sprawdzenie ogrodzeń",
    "Karmienie dinozaurów",
    "Zbieranie próbek DNA",
    "Monitorowanie zdrowia zwierząt",
    "Konserwacja systemów bezpieczeństwa"
  ];
  return tasks[Math.floor(Math.random() * tasks.length)];
}

assignTasks("Dr. Henry Wu", "2023-06-15", "John", "Sarah", "Michael");
// Zadania na 2023-06-15 dla zespołu prowadzonego przez Dr. Henry Wu:
// - John: Sprawdzenie ogrodzeń
// - Sarah: Karmienie dinozaurów
// - Michael: Monitorowanie zdrowia zwierząt

Operator rozproszenia (spread)

Operator spread (...) jest przeciwieństwem parametru rest. Zamiast zbierać argumenty w tablicę, rozkłada tablicę (lub inny iterowalny obiekt) na poszczególne argumenty:

function monitorVitalSigns(dinoName, temperature, heartRate, respirationRate) {
  console.log(`Monitoring parametrów życiowych dla: ${dinoName}`);
  console.log(`- Temperatura: ${temperature}°C`);
  console.log(`- Tętno: ${heartRate} uderzeń/min`);
  console.log(`- Częstość oddychania: ${respirationRate} oddechów/min`);

  // Analiza parametrów i generowanie raportu
  if (temperature > 39 || heartRate > 140 || respirationRate > 30) {
    return "ALERT: Parametry życiowe poza normą!";
  }
  return "Parametry życiowe w normie.";
}

// Tablica z danymi o parametrach życiowych
const rexVitals = ["T-Rex", 38.2, 115, 22];

// Bez operatora spread
monitorVitalSigns(rexVitals[0], rexVitals[1], rexVitals[2], rexVitals[3]);

// Z operatorem spread - rozkłada tablicę na oddzielne argumenty
monitorVitalSigns(...rexVitals);

Operator spread jest również przydatny przy łączeniu tablic lub obiektów:

// Łączenie danych o dinozaurach z różnych systemów
const basicDinoData = {
  id: "VLR-01",
  name: "Blue",
  species: "Velociraptor"
};

const healthData = {
  weight: 100,
  health: "Dobry",
  lastCheckup: "2023-05-10"
};

const behavioralData = {
  temperament: "Agresywny",
  packStatus: "Beta",
  trainingLevel: "Zaawansowany"
};

// Tworzenie kompletnego obiektu danych o dinozaurze
const completeProfile = {
  ...basicDinoData,
  ...healthData,
  ...behavioralData,
  updatedAt: new Date().toISOString()
};

console.log(completeProfile);
// {
//   id: "VLR-01",
//   name: "Blue",
//   species: "Velociraptor",
//   weight: 100,
//   health: "Dobry",
//   lastCheckup: "2023-05-10",
//   temperament: "Agresywny",
//   packStatus: "Beta",
//   trainingLevel: "Zaawansowany",
//   updatedAt: "2023-06-15T10:30:00.000Z"
// }

Destrukturyzacja parametrów obiektowych

Gdy funkcje przyjmują wiele parametrów, często łatwiej jest przekazać je jako obiekt. Destrukturyzacja (ES6+) pozwala na eleganckie wyodrębnienie tych wartości:

// Funkcja akceptująca obiekt opcji
function createDinosaurEnclosure({ species, capacity, securityLevel, location, features = [] }) {
  console.log(`Tworzenie zagrody dla gatunku: ${species}`);
  console.log(`Pojemność: ${capacity} osobników`);
  console.log(`Poziom zabezpieczeń: ${securityLevel}/5`);
  console.log(`Lokalizacja: ${location}`);

  if (features.length > 0) {
    console.log("Dodatkowe funkcje zagrody:");
    features.forEach(feature => console.log(`- ${feature}`));
  }

  return `Zagroda dla ${species} została utworzona w lokalizacji ${location}`;
}

// Wywołanie z obiektem opcji
const enclosureResult = createDinosaurEnclosure({
  species: "Triceratops",
  capacity: 6,
  securityLevel: 3,
  location: "Sektor B",
  features: ["Zbiornik wodny", "Roślinność z okresu kredy", "Platforma obserwacyjna"]
});

console.log(enclosureResult);
// "Zagroda dla Triceratops została utworzona w lokalizacji Sektor B"

Możemy również ustawić domyślne wartości dla całego obiektu:

function scheduleLabTest({
  specimenId,
  testType = "DNA",
  priority = "Normal",
  assignedTo = "Dr. Wu"
} = {}) {  // Domyślny pusty obiekt zapobiega błędom, gdy nie podamy argumentu

  console.log(`Zaplanowano test ${testType} dla próbki #${specimenId}`);
  console.log(`Priorytet: ${priority}`);
  console.log(`Przypisany do: ${assignedTo}`);

  return `Test zaplanowany. ID testu: TEST-${specimenId}-${Date.now()}`;
}

// Wywołanie z wszystkimi opcjami
scheduleLabTest({
  specimenId: "VLR-42",
  testType: "Sekwencjonowanie genomu",
  priority: "Wysoki",
  assignedTo: "Dr. Sattler"
});

// Wywołanie z tylko wymaganym parametrem
scheduleLabTest({ specimenId: "TRX-05" });

// Wywołanie bez argumentów (zadziała dzięki domyślnemu pustemu obiektowi)
// scheduleLabTest(); // Bez domyślnego pustego obiektu to by wywołało błąd

Praktyczny przykład: System zarządzania incydentami

Połączmy poznane koncepcje, tworząc kompleksowy system zarządzania incydentami dla Parku Jurajskiego:

// System zarządzania incydentami
const incidentManager = (function() {
  // Prywatna tablica incydentów
  const incidents = [];

  // Prywatne funkcje pomocnicze
  function generateIncidentId() {
    return `INC-${Date.now()}-${Math.floor(Math.random() * 1000)}`;
  }

  function notifyTeam(incidentType, location, ...personnel) {
    console.log(`ALERT: Incydent typu "${incidentType}" w lokalizacji "${location}"`);

    if (personnel.length > 0) {
      console.log(`Powiadamianie personelu: ${personnel.join(', ')}`);
    } else {
      console.log("Powiadamianie całego personelu bezpieczeństwa");
    }
  }

  // Publiczne API
  return {
    // Metoda do raportowania nowego incydentu
    reportIncident: function({
      type,
      location,
      description,
      severity = "Średni",
      reportedBy,
      affectedAssets = [],
      notifyPersonnel = []
    }) {
      const incidentId = generateIncidentId();

      const incident = {
        id: incidentId,
        type,
        location,
        description,
        severity,
        reportedBy,
        affectedAssets,
        status: "Nowy",
        reportedAt: new Date().toISOString(),
        resolvedAt: null
      };

      incidents.push(incident);

      // Powiadomienie personelu
      notifyTeam(type, location, ...notifyPersonnel);

      return {
        incidentId,
        message: `Incydent #${incidentId} został zarejestrowany`
      };
    },

    // Metoda do aktualizacji statusu incydentu
    updateIncidentStatus: function(incidentId, newStatus, resolvedBy = null) {
      const incident = incidents.find(inc => inc.id === incidentId);

      if (!incident) {
        return { success: false, message: "Incydent nie znaleziony" };
      }

      incident.status = newStatus;

      if (newStatus === "Rozwiązany") {
        incident.resolvedAt = new Date().toISOString();
        incident.resolvedBy = resolvedBy;
      }

      return {
        success: true,
        message: `Status incydentu #${incidentId} zaktualizowany na "${newStatus}"`
      };
    },

    // Metoda do pobierania informacji o incydencie
    getIncidentInfo: function(incidentId) {
      const incident = incidents.find(inc => inc.id === incidentId);

      if (!incident) {
        return null;
      }

      return { ...incident }; // Zwracamy kopię, aby uniknąć modyfikacji oryginału
    },

    // Metoda do pobierania listy incydentów według kryteriów
    getIncidents: function({ status, type, severity, limit = 10 } = {}) {
      let result = [...incidents]; // Kopia tablicy

      // Filtrowanie według kryteriów
      if (status) {
        result = result.filter(inc => inc.status === status);
      }

      if (type) {
        result = result.filter(inc => inc.type === type);
      }

      if (severity) {
        result = result.filter(inc => inc.severity === severity);
      }

      // Sortowanie od najnowszych
      result.sort((a, b) => new Date(b.reportedAt) - new Date(a.reportedAt));

      // Limit wyników
      return result.slice(0, limit);
    }
  };
})();

// Przykładowe użycie systemu
const breakoutIncident = incidentManager.reportIncident({
  type: "Ucieczka dinozaura",
  location: "Zagroda Velociraptorów - Sektor C",
  description: "Trzy velociraptory wydostały się z zagrody. Personel parku ewakuowany.",
  severity: "Krytyczny",
  reportedBy: "Robert Muldoon",
  affectedAssets: ["VLR-02", "VLR-03", "VLR-04"],
  notifyPersonnel: ["Dr. Grant", "John Hammond", "Ellie Sattler", "Ian Malcolm"]
});

console.log(breakoutIncident.message);
// "Incydent #INC-1623844529123-456 został zarejestrowany"

// Aktualizacja statusu incydentu
const updateResult = incidentManager.updateIncidentStatus(
  breakoutIncident.incidentId,
  "W trakcie",
  "Zespół SWAT"
);
console.log(updateResult.message);
// "Status incydentu #INC-1623844529123-456 zaktualizowany na "W trakcie""

// Pobranie informacji o incydencie
const incidentDetails = incidentManager.getIncidentInfo(breakoutIncident.incidentId);
console.log(incidentDetails);

// Wyszukiwanie incydentów według kryteriów
const criticalIncidents = incidentManager.getIncidents({
  severity: "Krytyczny",
  limit: 5
});
console.log(`Znaleziono ${criticalIncidents.length} krytycznych incydentów`);

Ten przykład demonstruje:

  1. Użycie destrukturyzacji obiektów do przyjmowania parametrów funkcji
  2. Zastosowanie parametrów domyślnych
  3. Użycie parametru rest do obsługi zmiennej liczby argumentów
  4. Użycie operatora spread do przekazywania argumentów
  5. Zaawansowane przetwarzanie i filtrowanie danych na podstawie parametrów

Podsumowanie

Funkcje w JavaScript oferują wiele potężnych mechanizmów pracy z parametrami i argumentami, które pozwalają tworzyć elastyczne, czytelne i łatwe w użyciu API:

  • Parametry domyślne upraszczają obsługę opcjonalnych argumentów
  • Parametr rest umożliwia funkcjom przyjmowanie zmiennej liczby argumentów
  • Operator spread pozwala na przekazywanie elementów tablicy jako oddzielnych argumentów
  • Destrukturyzacja obiektów ułatwia pracę z wieloma parametrami poprzez ich organizację w obiekty

Dzięki tym mechanizmom możemy tworzyć funkcje, które są elastyczne, ale jednocześnie proste w użyciu - co jest kluczowe w zarządzaniu skomplikowanymi systemami, takimi jak nasz wirtualny Park Jurajski.

Funkcjom strzałkowym, które wprowadzają bardziej zwięzłą składnię i specjalne zachowanie dotyczące kontekstu this, poświęcona jest osobna lekcja tego modułu.

Kod do tej lekcji: index.js
// Parametry i argumenty funkcji - Park Jurajski
console.log("Laboratorium Funkcji Parku Jurajskiego");
console.log("Zarządzanie dinozaurami przez funkcje z parametrami\n");

// ===========================================
// 1. PODSTAWOWE FUNKCJE Z PARAMETRAMI
// ===========================================
console.log("=== 1. Funkcje z parametrami ===");

// Funkcja z pojedynczym parametrem
function feedDinosaur(dinoName) {
  console.log(`Karmienie dinozaura: ${dinoName}`);
}

feedDinosaur("T-Rex");
feedDinosaur("Velociraptor");

// Funkcja z wieloma parametrami
function addDinosaur(name, species, age, weight) {
  console.log(`\nDodawanie nowego dinozaura do systemu:`);
  console.log(`  Imię: ${name}`);
  console.log(`  Gatunek: ${species}`);
  console.log(`  Wiek: ${age} lat`);
  console.log(`  Waga: ${weight} kg`);
}

addDinosaur("Blue", "Velociraptor", 5, 80);
addDinosaur("Rexy", "Tyrannosaurus Rex", 8, 8000);

// ===========================================
// 2. PARAMETRY DOMYŚLNE (ES6)
// ===========================================
console.log("\n=== 2. Parametry domyślne ===");

function scheduleFeeding(dinoName, foodType = "mięso", time = "12:00") {
  console.log(`Zaplanowano karmienie ${dinoName}`);
  console.log(`   Pokarm: ${foodType}, Godzina: ${time}`);
}

scheduleFeeding("Triceratops", "rośliny", "10:30");
scheduleFeeding("Raptor"); // Użyje wartości domyślnych
scheduleFeeding("Rex", undefined, "15:45"); // Pomiń środkowy parametr

// Wyrażenia jako wartości domyślne
function createPaddock(paddockNumber, capacity = paddockNumber * 2) {
  console.log(`Tworzenie wybiegu #${paddockNumber} z pojemnością ${capacity}`);
}

createPaddock(5);
createPaddock(3, 10);

// ===========================================
// 3. REST PARAMETERS (...args)
// ===========================================
console.log("\n=== 3. Rest parameters (...) ===");

function feedMultipleDinosaurs(...dinoNames) {
  console.log(`Karmienie ${dinoNames.length} dinozaurów:`);
  dinoNames.forEach((name, index) => {
    console.log(`  ${index + 1}. ${name}`);
  });
}

feedMultipleDinosaurs("Rex", "Blue", "Charlie", "Delta");
feedMultipleDinosaurs("Triceratops", "Stegosaurus");

// Rest parameter z innymi parametrami
function assignToTeam(teamLeader, ...teamMembers) {
  console.log(`\nZespół kierowany przez: ${teamLeader}`);
  console.log(`   Członkowie zespołu: ${teamMembers.join(", ")}`);
}

assignToTeam("Dr. Grant", "Ellie", "Ian", "Lex", "Tim");

// ===========================================
// 4. DESTRUCTURING PARAMETERS
// ===========================================
console.log("\n=== 4. Destructuring w parametrach ===");

// Destructuring obiektów
function displayDinosaurInfo({ name, species, age, weight, carnivore }) {
  console.log(`\nInformacje o dinozaurze:`);
  console.log(`  Imię: ${name}`);
  console.log(`  Gatunek: ${species}`);
  console.log(`  Wiek: ${age} lat`);
  console.log(`  Waga: ${weight} kg`);
  console.log(`  Typ: ${carnivore ? "Mięsożerca" : "Roślinożerca"}`);
}

const dino = {
  name: "Blue",
  species: "Velociraptor",
  age: 5,
  weight: 80,
  carnivore: true
};

displayDinosaurInfo(dino);

// Destructuring z wartościami domyślnymi
function createEnclosure({ size = 100, type = "standard", security = "medium" } = {}) {
  console.log(`\nTworzenie ogrodzenia:`);
  console.log(`  Rozmiar: ${size} m²`);
  console.log(`  Typ: ${type}`);
  console.log(`  Zabezpieczenie: ${security}`);
}

createEnclosure({ size: 200, type: "high-security", security: "maximum" });
createEnclosure({ size: 150 });
createEnclosure(); // Wszystkie wartości domyślne

// Destructuring tablic
function assignPaddocks([first, second, third]) {
  console.log(`\nPrzypisywanie wybiegów:`);
  console.log(`  Wybieg A: ${first}`);
  console.log(`  Wybieg B: ${second}`);
  console.log(`  Wybieg C: ${third}`);
}

assignPaddocks(["T-Rex", "Triceratops", "Stegosaurus"]);

// ===========================================
// 5. RETURN VALUES
// ===========================================
console.log("\n=== 5. Zwracanie wartości ===");

function calculateDangerLevel(species, age, aggression) {
  let dangerScore = 0;

  if (species === "Tyrannosaurus") dangerScore += 50;
  else if (species === "Velociraptor") dangerScore += 40;
  else if (species === "Triceratops") dangerScore += 20;
  else dangerScore += 10;

  dangerScore += age * 2;
  dangerScore += aggression * 10;

  let level = "Niskie";
  if (dangerScore > 80) level = "Ekstremalne";
  else if (dangerScore > 60) level = "Wysokie";
  else if (dangerScore > 40) level = "Średnie";

  return {
    score: dangerScore,
    level: level,
    recommendation: dangerScore > 70 ? "Podwójne zabezpieczenie" : "Standardowe zabezpieczenie"
  };
}

const trexDanger = calculateDangerLevel("Tyrannosaurus", 8, 9);
console.log("Poziom zagrożenia T-Rex:", trexDanger);

const triDanger = calculateDangerLevel("Triceratops", 5, 3);
console.log("Poziom zagrożenia Triceratops:", triDanger);

// ===========================================
// 6. FUNKCJE ZWRACAJĄCE FUNKCJE
// ===========================================
console.log("\n=== 6. Funkcje wyższego rzędu ===");

function createFeeder(foodType) {
  return function(dinoName) {
    console.log(`Karmienie ${dinoName} używając: ${foodType}`);
  };
}

const meatFeeder = createFeeder("świeże mięso");
const plantFeeder = createFeeder("rośliny");

meatFeeder("T-Rex");
meatFeeder("Velociraptor");
plantFeeder("Triceratops");
plantFeeder("Brachiosaurus");

// ===========================================
// 7. CALLBACK FUNCTIONS
// ===========================================
console.log("\n=== 7. Funkcje callback ===");

function processDinosaurs(dinosaurs, callback) {
  console.log("\nPrzetwarzanie listy dinozaurów:");
  dinosaurs.forEach((dino, index) => {
    callback(dino, index);
  });
}

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

processDinosaurs(dinoList, (dino, index) => {
  console.log(`  ${index + 1}. ${dino} - Sprawdzenie zdrowia:`);
});

// ===========================================
// 8. ARGUMENTS OBJECT (Legacy)
// ===========================================
console.log("\n=== 8. Obiekt arguments (starszy sposób) ===");

function feedAll() {
  console.log(`Karmienie ${arguments.length} dinozaurów:`);
  for (let i = 0; i < arguments.length; i++) {
    console.log(`  ${i + 1}. ${arguments[i]}`);
  }
}

feedAll("Rex", "Blue", "Charlie", "Delta", "Echo");

// ===========================================
// 9. PRZYKŁAD KOMPLEKSOWY
// ===========================================
console.log("\n=== 9. System zarządzania parkiem - przykład kompleksowy ===");

function managePark({
  dinosaurs = [],
  visitors = 0,
  weather = "sunny",
  securityLevel = "medium"
} = {}) {
  console.log("\nRAPORT PARKU JURAJSKIEGO");
  console.log("================================");
  console.log(`Dinozaury w parku: ${dinosaurs.length}`);
  console.log(`Liczba odwiedzających: ${visitors}`);
  console.log(`Pogoda: ${weather}`);
  console.log(`Poziom bezpieczeństwa: ${securityLevel}`);

  if (dinosaurs.length > 0) {
    console.log("\nLista dinozaurów:");
    dinosaurs.forEach((dino, idx) => {
      console.log(`  ${idx + 1}. ${dino.name} (${dino.species})`);
    });
  }

  const isOpen = weather === "sunny" && securityLevel !== "low";
  console.log(`\nStatus parku: ${isOpen ? "OTWARTY" : "ZAMKNIĘTY"}`);

  return {
    isOperational: isOpen,
    totalDinosaurs: dinosaurs.length,
    capacity: visitors,
    status: isOpen ? "Operational" : "Closed"
  };
}

const parkStatus = managePark({
  dinosaurs: [
    { name: "Rexy", species: "T-Rex" },
    { name: "Blue", species: "Velociraptor" },
    { name: "Trike", species: "Triceratops" }
  ],
  visitors: 1500,
  weather: "sunny",
  securityLevel: "high"
});

console.log("\nPodsumowanie:", parkStatus);

console.log("\nGratulacje! Opanowałeś parametry i argumenty funkcji!");

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Które użycie template literals jest poprawne?

  2. 2. Co zwróci typeof null w JavaScript?

  3. 3. Jak poprawnie utworzyć BigInt reprezentujący liczbę lat od wyginięcia dinozaurów?

  4. 4. Jaka jest główna cecha typu Symbol w JavaScript?

  5. 5. Które słowa kluczowe tworzą zmienne o zasięgu blokowym?

Zadania praktyczne w grze

  • Klikanie w kolejności

    Posortuj słowa kluczowe deklaracji zmiennych od najmniej do najbardziej restrykcyjnego:

  • Układanie w poziomie

    Ułóż elementy wywołania metody toUpperCase na stringu:

  • Klikanie w kolejności

    Uporządkuj cykl życia zmiennej w JavaScript:

  1. PytanieTemplate literals
  2. PytanieSprawdzanie typów za pomocą typeof
  3. PytanieTyp danych BigInt
  4. Kliknij w kolejnościKolejność deklaracji zmiennych
  5. PytanieTyp danych Symbol
  6. PytanieZakres zmiennych
  7. Ułóż w kolejnościSkładnia wywołania metody stringa
  8. Kliknij w kolejnościCykl życia zmiennej

Przydatne artykuły