Kurs JavaScript i TypeScript · Moduł 2: Funkcje, tablice i obiekty
Funkcje strzałkowe (arrow functions)
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:
- Nie używa słowa kluczowego
function - 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:
- Bardziej zwięzła składnia - mniej kodu do napisania
- Leksykalne wiązanie
this- rozwiązuje wiele problemów z kontekstem - 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.