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

Funkcje strzałkowe (arrow functions)

8 min czytania ·
W tej lekcji7

Witaj ponownie w Parku Jurajskim! Dzisiaj poznamy funkcje strzałkowe (arrow functions) - nowoczesny sposób tworzenia funkcji w JavaScript, który został wprowadzony w ES6. Funkcje strzałkowe są bardziej zwięzłe niż tradycyjne wyrażenia funkcyjne i mają kilka unikalnych właściwości, które czynią je niezwykle przydatnymi w codziennej pracy.

Podstawowa składnia funkcji strzałkowych

Funkcje strzałkowe mają bardziej zwięzłą składnię niż tradycyjne funkcje. Porównajmy:

Tradycyjna funkcja:

// Tradycyjna funkcja anonimowa
const identifyDinosaur = function(species) {
  return "Zidentyfikowano gatunek: " + species;
};

Funkcja strzałkowa:

// Funkcja strzałkowa
const identifyDinosaur = (species) => {
  return "Zidentyfikowano gatunek: " + species;
};

Widzimy, że funkcja strzałkowa:

  1. Nie używa słowa kluczowego function
  2. Używa znaku strzałki => między parametrami a ciałem funkcji

Jeszcze większa zwięzłość

Funkcje strzałkowe oferują jeszcze bardziej skróconą składnię w następujących przypadkach:

Jeden parametr: można pominąć nawiasy

// Z nawiasami
const getSpeciesInfo = (species) => {
  return `Gatunek ${species} został znaleziony w bazie danych.`;
};

// Bez nawiasów - to samo
const getSpeciesInfoShort = species => {
  return `Gatunek ${species} został znaleziony w bazie danych.`;
};

Funkcja jednolinijkowa: niejawny return

Jeśli ciało funkcji składa się tylko z jednego wyrażenia zwracającego wartość, możemy pominąć nawiasy klamrowe i słowo kluczowe return:

// Z return
const getSpeciesAge = (species) => {
  return species === "Tyrannosaurus" ? "68 milionów lat" : "Wiek nieznany";
};

// Z niejawnym return - to samo
const getSpeciesAgeShort = (species) => species === "Tyrannosaurus" ? "68 milionów lat" : "Wiek nieznany";

Zwracanie obiektu

Przy zwracaniu obiektu musimy użyć nawiasów okrągłych wokół obiektu, aby nie był on interpretowany jako blok kodu:

// Niepoprawne - JavaScript pomyśli, że to blok kodu
// const getDinoData = (name, species) => { name: name, species: species };

// Poprawne - obiekt otoczony nawiasami
const getDinoData = (name, species) => ({ name: name, species: species });

const blue = getDinoData("Blue", "Velociraptor");
console.log(blue); // { name: "Blue", species: "Velociraptor" }

Praktyczne zastosowania funkcji strzałkowych

1. Przetwarzanie kolekcji danych

Funkcje strzałkowe są szczególnie przydatne przy metodach tablic takich jak map, filter, reduce:

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

// Filtrowanie drapieżników
const carnivores = dinosaurs.filter(dino => dino.carnivore);

// Mapowanie na nazwy gatunków
const speciesList = dinosaurs.map(dino => dino.species);

// Obliczanie łącznej wagi wszystkich dinozaurów
const totalWeight = dinosaurs.reduce((sum, dino) => sum + dino.weight, 0);

console.log("Drapieżniki:", carnivores.length);
console.log("Gatunki:", speciesList.join(", "));
console.log("Łączna waga:", totalWeight, "kg");

2. Obiekty z metodami

Funkcje strzałkowe przydają się wewnątrz metod obiektu, np. jako funkcje zwrotne w setInterval, bo zachowują this metody (o czym więcej nieco później):

const dinoMonitor = {
  dinosaurs: ["T-Rex", "Velociraptor", "Triceratops"],
  lastUpdated: null,

  init() {
    this.update();

    // Ustaw aktualizację co 60 sekund
    setInterval(() => {
      this.update();
      console.log("Monitor zaktualizowany");
    }, 60000);
  },

  update() {
    this.lastUpdated = new Date().toISOString();
    console.log(`Monitorowane dinozaury: ${this.dinosaurs.join(", ")}`);
  }
};

dinoMonitor.init();

Kluczowa różnica: zachowanie this

Najważniejszą różnicą między funkcjami strzałkowymi a tradycyjnymi funkcjami jest sposób, w jaki wiążą one kontekst this.

Funkcje tradycyjne: dynamiczne wiązanie this

W tradycyjnych funkcjach, this jest określane w momencie wywołania funkcji i może się zmieniać:

function DinoTracker() {
  this.zone = "Nieznana";

  this.updateZone = function(newZone) {
    this.zone = newZone;
    console.log(`Strefa: ${this.zone}`);
  };

  // Problem: 'this' w zwykłej funkcji przekazanej do setInterval nie wskazuje na DinoTracker (w przeglądarce to window, w Node.js obiekt Timeout)
  setInterval(function() {
    console.log(`Aktualna strefa: ${this.zone}`); // undefined
  }, 1000);
}

const tracker = new DinoTracker();
tracker.updateZone("Zagroda A");

Funkcje strzałkowe: leksykalne wiązanie this

Funkcje strzałkowe nie mają własnego this. Zamiast tego, dziedziczą this z zakresu, w którym zostały zdefiniowane (tzw. wiązanie leksykalne):

function DinoTracker() {
  this.zone = "Nieznana";

  this.updateZone = function(newZone) {
    this.zone = newZone;
    console.log(`Strefa: ${this.zone}`);
  };

  // Rozwiązanie: funkcja strzałkowa zachowuje 'this' z otaczającego zakresu
  setInterval(() => {
    console.log(`Aktualna strefa: ${this.zone}`); // Działa!
  }, 1000);
}

const tracker = new DinoTracker();
tracker.updateZone("Zagroda A");

Kiedy NIE używać funkcji strzałkowych

Mimo swoich zalet, funkcje strzałkowe nie są odpowiednie we wszystkich sytuacjach:

1. Metody obiektu (gdy potrzebujemy własnego this)

// ŹLE - funkcja strzałkowa nie ma własnego 'this'
const dinoBad = {
  name: "Blue",
  introduce: () => {
    console.log(`Cześć, jestem ${this.name}`); // this nie wskazuje na obiekt dino, więc imienia Blue tu nie zobaczysz
  }
};

// DOBRZE - tradycyjna funkcja ma własny kontekst 'this'
const dinoGood = {
  name: "Blue",
  introduce: function() {
    console.log(`Cześć, jestem ${this.name}`); // Działa!
  }
};

// DOBRZE - skrócona składnia metod w ES6
const dinoShort = {
  name: "Blue",
  introduce() {
    console.log(`Cześć, jestem ${this.name}`); // Też działa!
  }
};

2. Funkcje konstruktora (gdy używamy new)

// ŹLE - funkcje strzałkowe nie mogą być konstruktorami
const DinosaurArrow = (name, species) => {
  this.name = name;
  this.species = species;
};

// Spowoduje błąd:
// const rex = new DinosaurArrow("Rex", "Tyrannosaurus");

// DOBRZE - tradycyjna funkcja jako konstruktor
function Dinosaur(name, species) {
  this.name = name;
  this.species = species;
}

const rex = new Dinosaur("Rex", "Tyrannosaurus");
console.log(rex); // Dinosaur { name: "Rex", species: "Tyrannosaurus" }

3. Gdy potrzebujemy obiektu arguments

// ŹLE - funkcje strzałkowe nie mają własnego obiektu 'arguments'
const logArgsArrow = () => {
  console.log(arguments); // ReferenceError albo arguments funkcji otaczającej
};

// DOBRZE - tradycyjna funkcja ma własny obiekt 'arguments'
function logArgsRegular() {
  console.log(arguments); // obiekt podobny do tablicy z argumentami
}

// Alternatywnie w ES6 - użyj parametru rest
const logArgsRest = (...args) => {
  console.log(args); // tablica z argumentami
};

Praktyczny przykład: System monitorowania parku

Stwórzmy kompletny przykład systemu monitorowania Parku Jurajskiego, wykorzystując funkcje strzałkowe i ich unikalne właściwości:

const parkMonitoringSystem = {
  // Stan systemu
  status: "Offline",
  dinosaurs: [],
  sectors: [],
  securityAlerts: [],

  // Inicjalizacja systemu
  initialize() {
    this.status = "Uruchamianie";

    // Funkcja pomocnicza z zachowaniem kontekstu this
    const loadConfigs = () => {
      // Symulacja ładowania konfiguracji
      console.log("Ładowanie konfiguracji systemu...");

      // Użycie this z zakresu zewnętrznego
      setTimeout(() => {
        this.status = "Online";
        this.dinosaurs = [
          { id: "TRX-01", name: "Rex", species: "Tyrannosaurus", location: "Sektor A", status: "OK" },
          { id: "VLR-01", name: "Blue", species: "Velociraptor", location: "Sektor B", status: "OK" },
          { id: "TRC-01", name: "Trixie", species: "Triceratops", location: "Sektor C", status: "OK" }
        ];
        this.sectors = ["A", "B", "C", "D"];

        console.log(`System online. Monitorowanych dinozaurów: ${this.dinosaurs.length}`);
        this.startMonitoring();
      }, 2000);
    };

    loadConfigs();
  },

  // Rozpoczęcie monitoringu
  startMonitoring() {
    this.checkSecurity();

    // Sprawdzanie statusu co 5 minut
    setInterval(() => this.checkStatus(), 300000);

    // Zbieranie danych o dinozaurach co godzinę
    setInterval(() => this.collectData(), 3600000);

    console.log("Monitorowanie rozpoczęte");
  },

  // Sprawdzanie statusu dinozaurów
  checkStatus() {
    const timestamp = new Date().toISOString();

    // Użycie map z funkcją strzałkową
    const statusReport = this.dinosaurs.map(dino => ({
      id: dino.id,
      name: dino.name,
      status: dino.status,
      location: dino.location,
      timestamp
    }));

    console.log("Raport statusu dinozaurów:", statusReport);
    return statusReport;
  },

  // Sprawdzanie bezpieczeństwa
  checkSecurity() {
    console.log("Sprawdzanie stanu bezpieczeństwa parku...");

    // Użycie filter z funkcją strzałkową
    const compromisedSectors = this.sectors.filter(sector =>
      Math.random() < 0.1 // 10% szans na problem w każdym sektorze (symulacja)
    );

    if (compromisedSectors.length > 0) {
      // Użycie forEach z funkcją strzałkową
      compromisedSectors.forEach(sector => {
        const alert = {
          id: `ALERT-${Date.now()}`,
          sector,
          type: "Naruszenie bezpieczeństwa",
          timestamp: new Date().toISOString()
        };

        this.securityAlerts.push(alert);
        this.triggerAlert(alert);
      });
    } else {
      console.log("Wszystkie sektory bezpieczne");
    }
  },

  // Wywołanie alertu
  triggerAlert(alert) {
    console.log(`ALERT! ${alert.type} w sektorze ${alert.sector}!`);

    // Wywołanie odpowiednich procedur
    this.notifySecurityTeam(alert);
  },

  // Powiadomienie zespołu bezpieczeństwa
  notifySecurityTeam(alert) {
    const securityPersonnel = ["John Hammond", "Robert Muldoon", "Ray Arnold"];

    // Użycie funkcji strzałkowej do stworzenia wiadomości
    const createMessage = person => `Powiadamianie ${person} o alercie w sektorze ${alert.sector}`;

    // Wysłanie wiadomości do każdego członka zespołu
    securityPersonnel.forEach(person => {
      console.log(createMessage(person));
    });
  },

  // Zbieranie danych o dinozaurach
  collectData() {
    console.log("Zbieranie danych o dinozaurach...");

    // Użycie reduce z funkcją strzałkową
    const speciesCount = this.dinosaurs.reduce((counts, dino) => {
      counts[dino.species] = (counts[dino.species] || 0) + 1;
      return counts;
    }, {});

    console.log("Liczba dinozaurów według gatunków:", speciesCount);

    return {
      timestamp: new Date().toISOString(),
      totalCount: this.dinosaurs.length,
      speciesDistribution: speciesCount
    };
  }
};

// Rozpoczęcie działania systemu
parkMonitoringSystem.initialize();

Podsumowanie

Funkcje strzałkowe wprowadzają kilka istotnych zmian do języka JavaScript:

  1. Bardziej zwięzła składnia - mniej kodu do napisania
  2. Leksykalne wiązanie this - rozwiązuje wiele problemów z kontekstem
  3. Niejawny return - dla funkcji jednolinijkowych

To sprawia, że są one szczególnie przydatne w wielu sytuacjach, takich jak:

  • Funkcje przekazywane do metod tablic (map, filter, reduce)
  • Funkcje zwrotne (callbacks) w timerach, obsłudze zdarzeń
  • Krótkie funkcje pomocnicze

Jednocześnie pamiętajmy o ograniczeniach:

  • Brak własnego this (co jest zaletą lub wadą, w zależności od sytuacji)
  • Brak arguments (choć można użyć parametru rest)
  • Nie można ich używać jako konstruktorów

W naszym Parku Jurajskim, funkcje strzałkowe pomagają nam pisać bardziej zwięzły i przejrzysty kod, co jest niezwykle ważne przy zarządzaniu tak złożonym ekosystemem. W następnych modułach będziemy korzystać z funkcji strzałkowych w różnych kontekstach, co pozwoli nam jeszcze lepiej zrozumieć ich zastosowanie.

Kod do tej lekcji: index.js
// Funkcje strzałkowe - Park Jurajski
console.log("Laboratorium Funkcji Strzałkowych");
console.log("Nowoczesne podejście do funkcji w JavaScript\n");

// ===========================================
// 1. PODSTAWOWA SKŁADNIA
// ===========================================
console.log("=== 1. Składnia funkcji strzałkowych ===");

// Funkcja tradycyjna
function traditionalRoar(dino) {
  return `${dino} says: ROAAR!`;
}

// Funkcja strzałkowa - pełna składnia
const arrowRoar = (dino) => {
  return `${dino} says: ROAAR!`;
};

// Funkcja strzałkowa - skrócona (implicit return)
const shortRoar = dino => `${dino} says: ROAAR!`;

console.log(traditionalRoar("T-Rex"));
console.log(arrowRoar("Velociraptor"));
console.log(shortRoar("Triceratops"));

// ===========================================
// 2. RÓŻNE WARIANTY SKŁADNI
// ===========================================
console.log("\n=== 2. Warianty składni ===");

// Bez parametrów
const getDinosaurs = () => ["T-Rex", "Velociraptor", "Triceratops"];
console.log("Lista dinozaurów:", getDinosaurs());

// Jeden parametr (nawiasy opcjonalne)
const double = x => x * 2;
console.log("Podwojenie 5:", double(5));

// Wiele parametrów (nawiasy wymagane)
const calculateWeight = (length, species) => length * (species === "T-Rex" ? 1000 : 500);
console.log("Waga T-Rexa (12m):", calculateWeight(12, "T-Rex"), "kg");

// Zwracanie obiektu (wymaga nawiasów)
const createDino = (name, species) => ({
  name: name,
  species: species,
  createdAt: new Date().toISOString()
});

console.log("\nNowy dinozaur:", createDino("Blue", "Velociraptor"));

// ===========================================
// 3. PORÓWNANIE Z TRADYCYJNYMI FUNKCJAMI
// ===========================================
console.log("\n=== 3. Tradycyjna vs Arrow Function ===");

// Tradycyjna
function feedTraditional(dino) {
  console.log(`Karmienie ${dino} (tradycyjna funkcja)`);
}

// Arrow
const feedArrow = dino => {
  console.log(`Karmienie ${dino} (arrow function)`);
};

feedTraditional("T-Rex");
feedArrow("Velociraptor");

// ===========================================
// 4. ARROW FUNCTIONS Z METODAMI TABLICY
// ===========================================
console.log("\n=== 4. Arrow functions z metodami tablicy ===");

const dinosaurs = [
  { name: "Rex", species: "T-Rex", weight: 8000, carnivore: true },
  { name: "Blue", species: "Velociraptor", weight: 80, carnivore: true },
  { name: "Trike", species: "Triceratops", weight: 9000, carnivore: false },
  { name: "Brachio", species: "Brachiosaurus", weight: 50000, carnivore: false }
];

// map
const names = dinosaurs.map(dino => dino.name);
console.log("Imiona:", names);

// filter
const carnivores = dinosaurs.filter(dino => dino.carnivore);
console.log("\nMięsożercy:", carnivores.map(d => d.name));

// reduce
const totalWeight = dinosaurs.reduce((sum, dino) => sum + dino.weight, 0);
console.log("\nŁączna waga:", totalWeight, "kg");

// forEach
console.log("\nLista wszystkich dinozaurów:");
dinosaurs.forEach((dino, index) => {
  console.log(`  ${index + 1}. ${dino.name} - ${dino.species} (${dino.weight}kg)`);
});

// find
const heaviest = dinosaurs.find(dino => dino.weight > 10000);
console.log("\nNajcięższy (>10000kg):", heaviest ? heaviest.name : "Brak");

// some & every
const hasHerbivores = dinosaurs.some(dino => !dino.carnivore);
const allCarnivores = dinosaurs.every(dino => dino.carnivore);
console.log("\nCzy są roślinożercy?", hasHerbivores);
console.log("Czy wszyscy są mięsożercami?", allCarnivores);

// ===========================================
// 5. CHAIN METHODS (ŁAŃCUCHOWANIE)
// ===========================================
console.log("\n=== 5. Łańcuchowanie metod ===");

const dangerousHeavyDinos = dinosaurs
  .filter(dino => dino.carnivore)
  .filter(dino => dino.weight > 100)
  .map(dino => `${dino.name} (${dino.weight}kg)`)
  .sort();

console.log("Niebezpieczne i ciężkie dinozaury:", dangerousHeavyDinos);

// ===========================================
// 6. CALLBACK FUNCTIONS
// ===========================================
console.log("\n=== 6. Arrow functions jako callbacks ===");

function processDinosaurs(dinos, processor) {
  return dinos.map(processor);
}

const dinoSummaries = processDinosaurs(dinosaurs, dino =>
  `${dino.name}: ${dino.carnivore ? 'mięsożerca' : 'roślinożerca'} ${dino.weight}kg`
);

console.log("Podsumowania:");
dinoSummaries.forEach(summary => console.log(`  ${summary}`));

// ===========================================
// 7. ARROW FUNCTIONS W setTimeout/setInterval
// ===========================================
console.log("\n=== 7. Arrow functions z timing functions ===");

// setTimeout z arrow function
setTimeout(() => {
  console.log("⏰ Czas karmienia! (po 100ms)");
}, 100);

// Symulacja countdown
let countdown = 3;
const countInterval = setInterval(() => {
  if (countdown > 0) {
    console.log(`⏳ Odliczanie: ${countdown}...`);
    countdown--;
  } else {
    console.log("Start!");
    clearInterval(countInterval);
  }
}, 50);

// ===========================================
// 8. RÓŻNICA W ZACHOWANIU 'this'
// ===========================================
console.log("\n=== 8. Różnica w kontekście 'this' ===");

const park = {
  name: "Jurassic Park",
  dinosaurs: ["T-Rex", "Velociraptor", "Triceratops"],

  // Metoda z tradycyjną funkcją
  displayTraditional: function() {
    console.log(`\n${this.name} - Tradycyjna funkcja:`);
    // this.dinosaurs.forEach(function(dino) {
    //   // this tutaj NIE odnosi się do park!
    //   console.log(`  - ${dino}`);
    // });

    // Rozwiązanie: arrow function w forEach
    this.dinosaurs.forEach(dino => {
      console.log(`  - ${dino} z ${this.name}`);
    });
  },

  // Metoda z arrow function
  displayArrow: function() {
    console.log(`\n${this.name} - Arrow function:`);
    this.dinosaurs.forEach(dino => {
      console.log(`  - ${dino} z ${this.name}`);
    });
  }
};

park.displayTraditional();
park.displayArrow();

// ===========================================
// 9. KIEDY NIE UŻYWAĆ ARROW FUNCTIONS
// ===========================================
console.log("\n=== 9. Kiedy NIE używać arrow functions ===");

// NIE używaj jako metod obiektów (gdy potrzebujesz 'this')
const dinoObject = {
  name: "Rex",

  // ZŁE - arrow function jako metoda
  roarBad: () => {
    // this nie wskazuje na dinoObject!
    console.log("this.name:", typeof this.name); // undefined
  },

  // DOBRE - tradycyjna funkcja jako metoda
  roarGood: function() {
    console.log(`${this.name} says: ROAAR!`);
  }
};

dinoObject.roarBad();
dinoObject.roarGood();

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

const parkSystem = {
  name: "Isla Nublar",
  dinosaurs: [
    { id: 1, name: "Rexy", species: "T-Rex", sector: "A", health: 95, fed: true },
    { id: 2, name: "Blue", species: "Velociraptor", sector: "B", health: 100, fed: false },
    { id: 3, name: "Charlie", species: "Velociraptor", sector: "B", health: 88, fed: false },
    { id: 4, name: "Trike", species: "Triceratops", sector: "C", health: 92, fed: true }
  ],

  getHealthReport: function() {
    console.log(`\nRAPORT ZDROWIA - ${this.name}`);
    console.log("=".repeat(50));

    const avgHealth = this.dinosaurs
      .map(d => d.health)
      .reduce((sum, h) => sum + h, 0) / this.dinosaurs.length;

    console.log(`Średnie zdrowie: ${avgHealth.toFixed(1)}%`);

    const needsAttention = this.dinosaurs.filter(d => d.health < 90);

    if (needsAttention.length > 0) {
      console.log(`\nWymagają uwagi (${needsAttention.length}):`);
      needsAttention.forEach(d => {
        console.log(`  - ${d.name}: ${d.health}% zdrowia`);
      });
    }

    return { avgHealth, needsAttention: needsAttention.length };
  },

  getFeedingStatus: function() {
    console.log(`\nSTATUS KARMIENIA - ${this.name}`);
    console.log("=".repeat(50));

    const hungryDinos = this.dinosaurs
      .filter(d => !d.fed)
      .map(d => ({ name: d.name, sector: d.sector }))
      .sort((a, b) => a.sector.localeCompare(b.sector));

    if (hungryDinos.length > 0) {
      console.log(`Głodne dinozaury (${hungryDinos.length}):`);
      hungryDinos.forEach(d => {
        console.log(`  Sektor ${d.sector}: ${d.name}`);
      });
    } else {
      console.log("Wszystkie dinozaury nakarmione!");
    }

    return hungryDinos;
  },

  getSectorReport: function() {
    console.log(`\nRAPORT SEKTORÓW - ${this.name}`);
    console.log("=".repeat(50));

    const sectors = this.dinosaurs.reduce((acc, dino) => {
      if (!acc[dino.sector]) {
        acc[dino.sector] = [];
      }
      acc[dino.sector].push(dino.name);
      return acc;
    }, {});

    Object.entries(sectors)
      .sort(([a], [b]) => a.localeCompare(b))
      .forEach(([sector, dinos]) => {
        console.log(`  Sektor ${sector}: ${dinos.join(", ")}`);
      });

    return sectors;
  }
};

// Uruchom wszystkie raporty
parkSystem.getHealthReport();
parkSystem.getFeedingStatus();
parkSystem.getSectorReport();

console.log("\nGratulacje! Opanowałeś funkcje strzałkowe!");

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Zadania praktyczne w grze

  • Edytor kodu

    Masz dane: const ageYears = 25, const weightKg = 8000 i const heightM = 5.6. Oblicz ageDays, czyli wiek w dniach (rok ma 365 dni), oraz bmi, czyli wagę podzieloną przez kwadrat wzrostu. Wyświetl w konsoli ageDays i bmi zaokrąglone do dwóch miejsc po przecinku (toFixed(2)).

  • Układanie w poziomie

    Ułóż elementy poprawnej deklaracji zmiennej let z przypisaniem wartości:

  • Edytor kodu

    Masz dane: const fenceVoltage = 10000, const requiredVoltage = 8000, const visitorsInPark = 250 i const maxVisitors = 500. Utwórz zmienne logiczne: isFenceSecure (napięcie jest równe wymaganemu lub większe), isParkFull (liczba gości osiągnęła limit) i canAcceptVisitors (ogrodzenie jest bezpieczne i jednocześnie park nie jest pełny). Wyświetl wszystkie trzy w konsoli.

  1. Zadanie z kodemOperacje na liczbach
  2. Ułóż w kolejnościSkładnia deklaracji zmiennej let
  3. Zadanie z kodemLogika wartości logicznych

Przydatne artykuły