Kurs JavaScript i TypeScript · Moduł 2: Funkcje, tablice i obiekty
Słowo kluczowe this w JavaScript
W tej lekcji9
Witaj ponownie w Parku Jurajskim! Dzisiaj zagłębimy się w jedno z najbardziej intrygujących i czasami mylących zagadnień w JavaScript: słowo kluczowe this. Zrozumienie this jest kluczowe dla efektywnego programowania obiektowego w JavaScript i tworzenia złożonych systemów, takich jak nasz system zarządzania parkiem.
Czym jest this?
Słowo kluczowe this w JavaScript odnosi się do obiektu, w którego kontekście wykonywana jest funkcja. Można o nim myśleć jak o "aktualnym miejscu pracy" - podobnie jak pracownik Parku Jurajskiego może pracować w różnych lokalizacjach (np. laboratorium, zagroda T-Rexa, centrum kontroli), tak samo funkcja może być wykonywana w różnych kontekstach.
Wartość this nie jest ustalana w momencie definiowania funkcji, ale w momencie jej wywołania, co może powodować pewne zamieszanie. Wartość this zależy od tego, jak funkcja jest wywoływana:
- W kontekście globalnym
- Jako metoda obiektu
- Jako konstruktor
- Za pomocą metod
call(),apply()lubbind() - W funkcjach strzałkowych
Przyjrzyjmy się każdemu z tych przypadków.
1. This w kontekście globalnym
Gdy this jest używane w zwykłej funkcji (niewywołanej jako metoda obiektu, poza trybem ścisłym), odnosi się do obiektu globalnego: w przeglądarce window, a w Node.js global (wspólna nazwa obu to globalThis). Na najwyższym poziomie skryptu w przeglądarce this to też window, ale w pliku Node.js to module.exports, czyli pusty obiekt {}, a w modułach ES - undefined.
// W globalnym zasięgu
console.log(this); // window w przeglądarce, {} (module.exports) w pliku Node.js
// W zwykłej funkcji
function checkGlobalThis() {
console.log(this); // również obiekt window/global
}
checkGlobalThis();W trybie ścisłym ("use strict";), this w zwykłej funkcji będzie undefined zamiast obiektu globalnego, co pomaga uniknąć przypadkowego tworzenia globalnych zmiennych.
"use strict";
function strictThis() {
console.log(this); // undefined
}
strictThis();2. This jako metoda obiektu
Gdy funkcja jest wywoływana jako metoda obiektu, this odnosi się do tego obiektu. Jest to jeden z najczęstszych i najbardziej intuicyjnych sposobów użycia this w JavaScript.
// Obiekt reprezentujący dinozaura
const velociraptor = {
name: "Blue",
species: "Velociraptor",
age: 5,
// Metoda wykorzystująca this
describe: function() {
console.log(`Ten ${this.species} ma na imię ${this.name} i ma ${this.age} lat.`);
},
// Metoda zmieniająca dane dinozaura
ageDinosaur: function(years) {
this.age += years;
console.log(`${this.name} ma teraz ${this.age} lat.`);
}
};
// Wywołanie metod
velociraptor.describe(); // "Ten Velociraptor ma na imię Blue i ma 5 lat."
velociraptor.ageDinosaur(2); // "Blue ma teraz 7 lat."W powyższym przykładzie, this wewnątrz metod describe i ageDinosaur odnosi się do obiektu velociraptor, dzięki czemu metody mają dostęp do jego właściwości.
Potencjalna pułapka: utrata kontekstu
Jednak trzeba uważać - kontekst this może zostać utracony, jeśli metodę przypiszemy do innej zmiennej i wywołamy ją jako zwykłą funkcję:
const velociraptor = {
name: "Blue",
describe: function() {
console.log(`Cześć, jestem ${this.name}!`);
}
};
// Wywołanie jako metoda - this odnosi się do velociraptor
velociraptor.describe(); // "Cześć, jestem Blue!"
// Ale gdy przypiszemy metodę do zmiennej...
const describeDino = velociraptor.describe;
// ...i wywołamy jako zwykłą funkcję
describeDino(); // "Cześć, jestem undefined!"
// (lub "Cześć, jestem !", jeśli istnieje globalna zmienna name)To częsty problem przy przekazywaniu metod jako funkcji zwrotnych (callbacks):
const trex = {
name: "Rex",
roar: function() {
console.log(`${this.name} ryczy głośno!`);
}
};
// Bezpośrednie wywołanie działa
trex.roar(); // "Rex ryczy głośno!"
// Ale jako callback po 1 sekundzie...
setTimeout(trex.roar, 1000); // this nie wskazuje na trex, więc imię Rex się nie pojawi
// Rozwiązanie (jednym ze sposobów) jest użycie funkcji strzałkowej lub bind():
setTimeout(() => trex.roar(), 1000); // "Rex ryczy głośno!"
setTimeout(trex.roar.bind(trex), 1000); // "Rex ryczy głośno!"3. This w konstruktorach
Gdy funkcja jest wywoływana z operatorem new (jako konstruktor), this odnosi się do nowo tworzonego obiektu. Jest to fundamentalny mechanizm tworzenia instancji obiektów w JavaScript.
// Funkcja konstruktora dla dinozaurów
function Dinosaur(name, species, age) {
// 'this' odnosi się do nowo tworzonego obiektu
this.name = name;
this.species = species;
this.age = age;
this.describe = function() {
console.log(`${this.name} to ${this.species} w wieku ${this.age} lat.`);
};
}
// Tworzenie nowych instancji
const blue = new Dinosaur("Blue", "Velociraptor", 5);
const rex = new Dinosaur("Rex", "Tyrannosaurus", 8);
blue.describe(); // "Blue to Velociraptor w wieku 5 lat."
rex.describe(); // "Rex to Tyrannosaurus w wieku 8 lat."
// Zmodyfikujmy wiek Blue
blue.age = 6;
blue.describe(); // "Blue to Velociraptor w wieku 6 lat."W nowoczesnym JavaScript (ES6+) zamiast funkcji konstruktora często używamy klas, które zapewniają bardziej przejrzystą składnię do robienia tego samego:
// Klasa ES6 dla dinozaurów
class Dinosaur {
constructor(name, species, age) {
this.name = name;
this.species = species;
this.age = age;
}
// Metody są automatycznie dodawane do prototypu
describe() {
console.log(`${this.name} to ${this.species} w wieku ${this.age} lat.`);
}
// Metoda zmieniająca wiek
growOlder(years = 1) {
this.age += years;
console.log(`${this.name} ma teraz ${this.age} lat.`);
}
}
// Tworzenie instancji
const trixie = new Dinosaur("Trixie", "Triceratops", 7);
trixie.describe(); // "Trixie to Triceratops w wieku 7 lat."
trixie.growOlder(3); // "Trixie ma teraz 10 lat."4. Kontrolowanie this: call(), apply() i bind()
JavaScript oferuje trzy metody, które pozwalają jawnie kontrolować wartość this podczas wywoływania funkcji:
call()
Metoda call() wywołuje funkcję z podaną wartością this i argumentami przekazanymi pojedynczo:
function examineSpecimen(testType, labNumber) {
console.log(`Badanie ${this.species} o imieniu ${this.name}...`);
console.log(`Typ testu: ${testType}, Laboratorium: ${labNumber}`);
}
const specimen = {
name: "Echo",
species: "Velociraptor",
age: 3
};
// Wywołanie funkcji z 'this' ustawionym na specimen
examineSpecimen.call(specimen, "DNA", "Lab-A");
// "Badanie Velociraptor o imieniu Echo..."
// "Typ testu: DNA, Laboratorium: Lab-A"apply()
Metoda apply() działa podobnie do call(), ale argumenty są przekazywane jako tablica:
// Ta sama funkcja
function examineSpecimen(testType, labNumber) {
console.log(`Badanie ${this.species} o imieniu ${this.name}...`);
console.log(`Typ testu: ${testType}, Laboratorium: ${labNumber}`);
}
// Wywołanie z argumentami w tablicy
examineSpecimen.apply(specimen, ["Behawioralny", "Lab-B"]);
// "Badanie Velociraptor o imieniu Echo..."
// "Typ testu: Behawioralny, Laboratorium: Lab-B"bind()
Metoda bind() tworzy nową funkcję z trwale przypisaną wartością this:
const dinosaur = {
name: "Delta",
species: "Velociraptor"
};
function makeSound(sound) {
console.log(`${this.name} wydaje dźwięk: ${sound}!`);
}
// Tworzenie nowej funkcji z 'this' przypisanym do dinosaur
const dinosaurSound = makeSound.bind(dinosaur);
// Teraz możemy wywoływać tę funkcję wielokrotnie
dinosaurSound("Warczenie"); // "Delta wydaje dźwięk: Warczenie!"
dinosaurSound("Syczenie"); // "Delta wydaje dźwięk: Syczenie!"
// Możemy też powiązać argumenty
const deltaRoar = makeSound.bind(dinosaur, "ROAR");
deltaRoar(); // "Delta wydaje dźwięk: ROAR!"Praktyczny przykład: Tworzenie systemu śledzenia dinozaurów
Poniższy przykład pokazuje, jak można wykorzystać różne metody kontrolowania this do tworzenia elastycznego systemu monitorowania:
const dinoMonitoringSystem = {
activeDinosaurs: [],
// Rejestracja nowego dinozaura
registerDinosaur: function(dinosaur) {
this.activeDinosaurs.push(dinosaur);
console.log(`Zarejestrowano nowego dinozaura: ${dinosaur.name} (${dinosaur.species})`);
},
// Wyszukiwanie dinozaura po imieniu
findDinosaurByName: function(name) {
return this.activeDinosaurs.find(dino => dino.name === name);
},
// Uruchomienie procedury alertu
triggerAlert: function(message) {
console.log(`ALERT SYSTEMOWY: ${message}`);
// Powiadamianie o wszystkich aktywnych dinozaurach
this.activeDinosaurs.forEach(function(dino) {
console.log(`- ${dino.name} (${dino.species}) w sektorze ${dino.sector}`);
});
}
};
// Klasa Dinosaur z metodą przemieszczania
class Dinosaur {
constructor(name, species, sector) {
this.name = name;
this.species = species;
this.sector = sector;
this.status = "spokojny";
}
move(newSector, monitoringSystem) {
// Możemy przekazać monitoringSystem jako parametr
console.log(`${this.name} przemieszcza się z sektora ${this.sector} do sektora ${newSector}`);
this.sector = newSector;
// Lub użyć call() do wywołania metody z właściwym kontekstem
const alertMessage = `Dinozaur ${this.name} wszedł do sektora ${newSector}!`;
monitoringSystem.triggerAlert.call(monitoringSystem, alertMessage);
}
// Metoda zmieniająca status dinozaura
updateStatus(newStatus) {
this.status = newStatus;
console.log(`Status dinozaura ${this.name} zmieniony na: ${this.status}`);
return this;
}
}
// Inicjalizacja systemu i dinozaurów
const rex = new Dinosaur("Rex", "Tyrannosaurus", "A");
const blue = new Dinosaur("Blue", "Velociraptor", "B");
const delta = new Dinosaur("Delta", "Velociraptor", "B");
// Rejestracja dinozaurów w systemie
dinoMonitoringSystem.registerDinosaur(rex);
dinoMonitoringSystem.registerDinosaur(blue);
dinoMonitoringSystem.registerDinosaur(delta);
// Przemieszczenie dinozaura
blue.move("C", dinoMonitoringSystem);
// Łańcuchowanie metod (dzięki return this)
rex.updateStatus("pobudzony").updateStatus("agresywny");
// Wykorzystanie bind() do tworzenia funkcji z predefiniowanym 'this'
const checkRexStatus = function() {
console.log(`Status T-Rexa: ${this.status}`);
};
const boundCheckStatus = checkRexStatus.bind(rex);
boundCheckStatus(); // "Status T-Rexa: agresywny"5. This w funkcjach strzałkowych
Funkcje strzałkowe, wprowadzone w ES6, obsługują this inaczej niż tradycyjne funkcje. Nie mają własnego this, zamiast tego "dziedziczą" this z otaczającego zakresu leksykalnego.
const parkSystem = {
name: "Jurassic Park",
dinosaurs: ["T-Rex", "Velociraptor", "Triceratops"],
// Metoda wykorzystująca funkcję strzałkową
listDinosaurs: function() {
console.log(`${this.name} zawiera następujące dinozaury:`);
// Funkcja strzałkowa zachowuje 'this' z zakresu listDinosaurs
this.dinosaurs.forEach(dino => {
console.log(`- ${dino} w parku ${this.name}`);
});
// Dla porównania - tradycyjna funkcja straciłaby kontekst 'this'
/*
this.dinosaurs.forEach(function(dino) {
// 'this' odnosi się do globalnego obiektu lub jest undefined w trybie ścisłym
console.log(`- ${dino} w parku ${this.name}`); // this.name będzie undefined
});
*/
}
};
parkSystem.listDinosaurs();
// "Jurassic Park zawiera następujące dinozaury:"
// "- T-Rex w parku Jurassic Park"
// "- Velociraptor w parku Jurassic Park"
// "- Triceratops w parku Jurassic Park"Funkcje strzałkowe są szczególnie przydatne w przypadkach, gdy chcemy zachować kontekst this w funkcjach zagnieżdżonych, funkcjach zwrotnych (callbacks) lub programowaniu asynchronicznym.
Praktyczny przykład: System monitorowania z czasomierzami
class DinosaurMonitor {
constructor(name, species) {
this.name = name;
this.species = species;
this.status = "Normalny";
this.lastUpdated = new Date();
this.checkInterval = null;
}
// Rozpoczęcie monitorowania z regularnym sprawdzaniem statusu
startMonitoring() {
console.log(`Rozpoczęcie monitorowania dinozaura: ${this.name}`);
// Funkcja strzałkowa zachowuje kontekst 'this'
this.checkInterval = setInterval(() => {
this.checkStatus();
}, 5000);
// Gdybyśmy użyli zwykłej funkcji, stracilibyśmy kontekst:
/*
this.checkInterval = setInterval(function() {
// 'this' odnosi się tutaj do globalnego obiektu, nie do instancji DinosaurMonitor
this.checkStatus(); // Błąd: this.checkStatus is not a function
}, 5000);
*/
}
// Sprawdzenie statusu dinozaura
checkStatus() {
const now = new Date();
const timeSinceLastUpdate = (now - this.lastUpdated) / 1000; // w sekundach
console.log(`Sprawdzanie statusu dinozaura ${this.name} (${this.species})...`);
console.log(`Ostatnia aktualizacja: ${timeSinceLastUpdate.toFixed(1)} sekund temu`);
console.log(`Status: ${this.status}`);
this.lastUpdated = now;
// Symulacja zmiany statusu (w rzeczywistym systemie byłyby tu dane z czujników)
if (Math.random() < 0.3) {
const possibleStatuses = ["Normalny", "Pobudzony", "Odpoczywający", "Żerujący", "Agresywny"];
this.status = possibleStatuses[Math.floor(Math.random() * possibleStatuses.length)];
console.log(`Nowy status: ${this.status}`);
}
}
// Zatrzymanie monitorowania
stopMonitoring() {
if (this.checkInterval) {
clearInterval(this.checkInterval);
this.checkInterval = null;
console.log(`Zatrzymano monitorowanie dinozaura: ${this.name}`);
}
}
}
// Utworzenie i uruchomienie monitora
const blueMonitor = new DinosaurMonitor("Blue", "Velociraptor");
blueMonitor.startMonitoring();
// Zatrzymanie monitora po 20 sekundach
setTimeout(() => {
blueMonitor.stopMonitoring();
}, 20000);Typowe pułapki związane z this
Słowo kluczowe this może być źródłem wielu błędów w JavaScript. Oto kilka typowych pułapek i jak ich unikać:
1. Utrata kontekstu w funkcjach zagnieżdżonych
const dinosaur = {
name: "Rex",
behaviors: ["polowanie", "odpoczynek", "bieganie"],
logBehaviors: function() {
// 'this' odnosi się tutaj do 'dinosaur'
console.log(`Dinozaur ${this.name} wykazuje następujące zachowania:`);
// Problem: 'this' w funkcji forEach odnosi się do globalnego obiektu
this.behaviors.forEach(function(behavior) {
// 'this.name' jest undefined
console.log(`- ${this.name} lubi ${behavior}`);
});
}
};
dinosaur.logBehaviors();
// "Dinozaur Rex wykazuje następujące zachowania:"
// "- undefined lubi polowanie"
// "- undefined lubi odpoczynek"
// "- undefined lubi bieganie"Rozwiązania:
- Użyj funkcji strzałkowej:
const dinosaur = {
name: "Rex",
behaviors: ["polowanie", "odpoczynek", "bieganie"],
logBehaviors: function() {
console.log(`Dinozaur ${this.name} wykazuje następujące zachowania:`);
// Funkcja strzałkowa zachowuje 'this' z otaczającego zakresu
this.behaviors.forEach(behavior => {
console.log(`- ${this.name} lubi ${behavior}`);
});
}
};- Zachowaj referencję do
thisw zmiennej:
const dinosaur = {
name: "Rex",
behaviors: ["polowanie", "odpoczynek", "bieganie"],
logBehaviors: function() {
console.log(`Dinozaur ${this.name} wykazuje następujące zachowania:`);
// Zachowanie referencji do 'this' w zmiennej 'self' lub 'that'
const self = this;
this.behaviors.forEach(function(behavior) {
console.log(`- ${self.name} lubi ${behavior}`);
});
}
};- Użyj metody
bind():
const dinosaur = {
name: "Rex",
behaviors: ["polowanie", "odpoczynek", "bieganie"],
logBehaviors: function() {
console.log(`Dinozaur ${this.name} wykazuje następujące zachowania:`);
// Użycie bind() do powiązania 'this'
this.behaviors.forEach(function(behavior) {
console.log(`- ${this.name} lubi ${behavior}`);
}.bind(this));
}
};2. Metody jako callbacks
Gdy metoda obiektu jest przekazywana jako callback, traci swój kontekst this:
class DinosaurTracker {
constructor(name) {
this.name = name;
this.tracked = false;
}
startTracking() {
this.tracked = true;
console.log(`Rozpoczęto śledzenie dinozaura ${this.name}`);
}
}
const blueTracker = new DinosaurTracker("Blue");
// Działa poprawnie
blueTracker.startTracking();
// Nie działa - 'this' nie odnosi się do blueTracker
setTimeout(blueTracker.startTracking, 1000); // this nie wskazuje na blueTrackerRozwiązania:
- Użyj funkcji strzałkowej:
setTimeout(() => blueTracker.startTracking(), 1000);- Użyj
bind():
setTimeout(blueTracker.startTracking.bind(blueTracker), 1000);Zaawansowany przykład: System zarządzania parkiem
Poniżej znajduje się bardziej złożony przykład systemu zarządzania Parkiem Jurajskim, który wykorzystuje różne aspekty słowa kluczowego this:
// Główny system zarządzania parkiem
const parkManagementSystem = {
parkName: "Jurassic Park",
status: "operational",
securityLevel: "normal",
// Podsystemy parku
subsystems: {
power: { status: "online", output: "100%" },
security: { status: "active", fences: "operational" },
visitorCenter: { status: "open", visitors: 120 }
},
// Metoda inicjująca system
initialize: function() {
console.log(`Inicjalizacja systemu zarządzania parkiem: ${this.parkName}`);
// Sprawdzenie wszystkich podsystemów
this.checkAllSubsystems();
// Ustawienie regularnego monitorowania
this.startMonitoring();
return this;
},
// Sprawdzenie stanu podsystemów
checkAllSubsystems: function() {
console.log("Sprawdzanie statusu wszystkich podsystemów...");
// Użycie Object.entries i funkcji strzałkowej dla zachowania kontekstu 'this'
Object.entries(this.subsystems).forEach(([name, system]) => {
console.log(`- Podsystem ${name}: ${system.status}`);
// Wywołanie specyficznych sprawdzeń dla każdego podsystemu
this[`check${name.charAt(0).toUpperCase() + name.slice(1)}`]();
});
},
// Specyficzne metody sprawdzające dla każdego podsystemu
checkPower: function() {
const powerSystem = this.subsystems.power;
console.log(` Sprawdzanie zasilania: ${powerSystem.status}, Moc: ${powerSystem.output}`);
},
checkSecurity: function() {
const securitySystem = this.subsystems.security;
console.log(` Sprawdzanie zabezpieczeń: ${securitySystem.status}, Ogrodzenia: ${securitySystem.fences}`);
},
checkVisitorCenter: function() {
const visitorSystem = this.subsystems.visitorCenter;
console.log(` Sprawdzanie centrum dla zwiedzających: ${visitorSystem.status}, Odwiedzający: ${visitorSystem.visitors}`);
},
// Rozpoczęcie regularnego monitorowania
startMonitoring: function() {
console.log("Rozpoczęcie regularnego monitorowania parku...");
// Funkcja strzałkowa dla zachowania kontekstu 'this'
this.monitoringInterval = setInterval(() => {
this.checkSecurityStatus();
}, 10000);
// Symulacja wywołania metody po 5 sekundach
setTimeout(() => this.simulateSecurityAlert(), 5000);
},
// Sprawdzenie statusu bezpieczeństwa
checkSecurityStatus: function() {
console.log(`[MONITOR] Status parku: ${this.status}, Poziom bezpieczeństwa: ${this.securityLevel}`);
},
// Symulacja alertu bezpieczeństwa
simulateSecurityAlert: function() {
console.log("SYMULACJA: Wykryto naruszenie zabezpieczeń w sektorze B!");
// Zmiana statusu parku i poziomu bezpieczeństwa
this.status = "alert";
this.securityLevel = "high";
console.log(`Status parku zmieniony na: ${this.status}`);
console.log(`Poziom bezpieczeństwa podniesiony do: ${this.securityLevel}`);
// Bezpośrednie sprawdzenie statusu
this.checkSecurityStatus();
// Utworzenie zespołu reagowania kryzysowego używając konstruktora
const responseTeam = new EmergencyResponseTeam(this);
// Przekazanie metody jako callback z zachowaniem kontekstu
responseTeam.respondToAlert(this.resolveSecurityAlert.bind(this));
},
// Rozwiązanie alertu bezpieczeństwa
resolveSecurityAlert: function(report) {
console.log(`Otrzymano raport od zespołu reagowania: ${report}`);
// Przywrócenie normalnego statusu
this.status = "operational";
this.securityLevel = "normal";
console.log("Alert bezpieczeństwa rozwiązany.");
console.log(`Status parku przywrócony do: ${this.status}`);
// Sprawdzenie aktualnego statusu
this.checkSecurityStatus();
},
// Zatrzymanie monitorowania
stopMonitoring: function() {
if (this.monitoringInterval) {
clearInterval(this.monitoringInterval);
console.log("Monitorowanie parku zatrzymane.");
}
}
};
// Konstruktor dla zespołu reagowania kryzysowego
function EmergencyResponseTeam(park) {
// 'this' odnosi się do nowego obiektu
this.teamName = "Zespół Reagowania Kryzysowego";
this.members = ["Owen Grady", "Claire Dearing", "Dr. Wu"];
this.assignedPark = park;
this.respondToAlert = function(callback) {
console.log(`${this.teamName} reaguje na alert w parku: ${this.assignedPark.parkName}`);
// Symulacja czasu reakcji
setTimeout(() => {
console.log(`${this.teamName} zabezpieczył obszar i przywrócił ogrodzenia.`);
// Wywołanie callbacka z raportem
if (typeof callback === 'function') {
callback("Zagrożenie zneutralizowane, ogrodzenia naprawione");
}
}, 3000);
};
}
// Inicjalizacja i uruchomienie systemu
parkManagementSystem.initialize();
// Zatrzymanie systemu po 20 sekundach
setTimeout(() => {
parkManagementSystem.stopMonitoring();
}, 20000);Podsumowanie i najlepsze praktyki
Słowo kluczowe this jest potężnym narzędziem w JavaScript, ale wymaga zrozumienia, jak się zachowuje w różnych kontekstach:
W globalnym kontekście:
thistowindoww przeglądarce imodule.exports({}) w pliku Node.js; w zwykłej funkcji poza trybem ścisłym - obiekt globalny (globalThis).W metodzie obiektu:
thisodnosi się do obiektu, który wywołał metodę.W konstruktorze:
thisodnosi się do nowo tworzonego obiektu.W funkcjach strzałkowych:
thisjest dziedziczone z otaczającego zakresu leksykalnego.Przy użyciu call/apply/bind:
thisjest jawnie określone przez programistę.
Najlepsze praktyki:
Używaj funkcji strzałkowych dla funkcji zwrotnych (callbacks) i funkcji zagnieżdżonych, aby zachować kontekst
this.Używaj metod
call(),apply()lubbind(), gdy potrzebujesz jawnie kontrolować wartośćthis.Unikaj tworzenia metod w konstruktorach, zamiast tego dodawaj je do prototypu, aby uniknąć duplikacji kodu.
Pamiętaj, że
thisjest ustalane podczas wywoływania funkcji, a nie podczas jej definiowania.Używaj klas ES6 zamiast tradycyjnych konstruktorów, aby uzyskać bardziej przejrzysty kod.
W następnej lekcji zajmiemy się głębiej tablicami w JavaScript, które są kluczowym elementem zarządzania kolekcjami danych w naszym Parku Jurajskim.
Kod do tej lekcji: index.js
// Słowo kluczowe 'this' - Park Jurajski
console.log("Laboratorium 'this' w JavaScript");
console.log("Zrozumienie kontekstu wykonania\n");
// ===========================================
// 1. PODSTAWY 'this'
// ===========================================
console.log("=== 1. Czym jest 'this'? ===");
// 'this' odnosi się do obiektu, w kontekście którego wykonuje się kod
const dinosaur = {
name: "Tyrannosaurus Rex",
age: 8,
roar: function() {
console.log(`\n${this.name} ryczy: ROAARRR!`);
console.log(` Wiek: ${this.age} lat`);
}
};
dinosaur.roar(); // 'this' wskazuje na obiekt 'dinosaur'
// ===========================================
// 2. 'this' W RÓŻNYCH KONTEKSTACH
// ===========================================
console.log("\n=== 2. Konteksty 'this' ===");
// Kontekst 1: Metoda obiektu
const raptor = {
name: "Velociraptor",
speed: 40,
run: function() {
console.log(`\n${this.name} biegnący z prędkością ${this.speed} km/h`);
}
};
raptor.run(); // this = raptor
// Kontekst 2: Funkcja globalna (strict mode)
function globalFunction() {
console.log("\nGlobalna funkcja - this:", typeof this);
// W strict mode: undefined
// Bez strict mode: window (przeglądarka) lub global (Node.js)
}
globalFunction();
// Kontekst 3: Konstruktor
function Dinosaur(name, species) {
this.name = name;
this.species = species;
this.roar = function() {
console.log(`${this.name} (${this.species}): ROAARRR!`);
};
}
const trex = new Dinosaur("Rexy", "T-Rex");
console.log("\nKonstruktor:");
console.log(` Imię: ${trex.name}`);
console.log(` Gatunek: ${trex.species}`);
trex.roar();
// ===========================================
// 3. UTRATA KONTEKSTU 'this'
// ===========================================
console.log("\n=== 3. Utrata kontekstu 'this' ===");
const park = {
name: "Jurassic Park",
dinosaurs: ["T-Rex", "Velociraptor", "Triceratops"],
displayDinosaurs: function() {
console.log(`\nDinozaury w ${this.name}:`);
// PROBLEM: forEach z tradycyjną funkcją
// this.dinosaurs.forEach(function(dino) {
// console.log(` - ${dino} z ${this.name}`); // this.name = undefined!
// });
// ROZWIĄZANIE 1: Arrow function
this.dinosaurs.forEach(dino => {
console.log(` - ${dino} z ${this.name}`);
});
}
};
park.displayDinosaurs();
// ROZWIĄZANIE 2: bind()
const park2 = {
name: "Isla Nublar",
dinosaurs: ["Stegosaurus", "Brachiosaurus"],
displayDinosaurs: function() {
console.log(`\nDinozaury w ${this.name}:`);
this.dinosaurs.forEach(function(dino) {
console.log(` - ${dino} z ${this.name}`);
}.bind(this)); // Przywiązanie this
}
};
park2.displayDinosaurs();
// ===========================================
// 4. METODY: call(), apply(), bind()
// ===========================================
console.log("\n=== 4. Metody: call(), apply(), bind() ===");
const dinoInfo = {
describe: function(habitat, diet) {
console.log(`\n${this.name}:`);
console.log(` Środowisko: ${habitat}`);
console.log(` Dieta: ${diet}`);
}
};
const dino1 = { name: "T-Rex" };
const dino2 = { name: "Triceratops" };
// call() - wywołanie z jawnym this i argumentami
dinoInfo.describe.call(dino1, "Las tropikalny", "Mięsożerca");
// apply() - jak call(), ale argumenty w tablicy
dinoInfo.describe.apply(dino2, ["Sawanna", "Roślinożerca"]);
// bind() - tworzy nową funkcję z przywiązanym this
const describeTRex = dinoInfo.describe.bind(dino1);
describeTRex("Dżungla", "Mięsożerca");
// ===========================================
// 5. ARROW FUNCTIONS I 'this'
// ===========================================
console.log("\n=== 5. Arrow functions i 'this' ===");
const enclosure = {
id: "A-7",
dinosaur: "Velociraptor",
// Tradycyjna metoda
checkTraditional: function() {
console.log(`\nWybieg ${this.id} (tradycyjna):`);
setTimeout(function() {
// console.log(` Dinozaur: ${this.dinosaur}`); // undefined! this się zmieniło
console.log(" this.dinosaur = undefined (utrata kontekstu)");
}, 100);
},
// Rozwiązanie z arrow function
checkArrow: function() {
console.log(`\nWybieg ${this.id} (arrow):`);
setTimeout(() => {
console.log(` Dinozaur: ${this.dinosaur}`); // Działa! Arrow zachowuje this
}, 100);
}
};
enclosure.checkTraditional();
setTimeout(() => {
enclosure.checkArrow();
}, 150);
// ===========================================
// 6. 'this' W KONSTRUKTORACH I KLASACH
// ===========================================
console.log("\n=== 6. 'this' w konstruktorach i klasach ===");
// Konstruktor funkcyjny
function DinosaurPark(name) {
this.name = name;
this.dinosaurs = [];
this.addDinosaur = function(dino) {
this.dinosaurs.push(dino);
console.log(`Dodano ${dino} do ${this.name}`);
};
this.getCount = function() {
return this.dinosaurs.length;
};
}
const park1 = new DinosaurPark("Park Jurajski");
park1.addDinosaur("T-Rex");
park1.addDinosaur("Velociraptor");
console.log(`Łącznie dinozaurów: ${park1.getCount()}`);
// Klasa ES6
class ModernPark {
constructor(name) {
this.name = name;
this.dinosaurs = [];
}
addDinosaur(dino) {
this.dinosaurs.push(dino);
console.log(`\nDodano ${dino} do ${this.name}`);
}
getCount() {
return this.dinosaurs.length;
}
displayAll() {
console.log(`\n${this.name} - Lista dinozaurów:`);
this.dinosaurs.forEach((dino, i) => {
console.log(` ${i + 1}. ${dino}`);
});
}
}
const park3 = new ModernPark("Isla Nublar");
park3.addDinosaur("Triceratops");
park3.addDinosaur("Stegosaurus");
park3.addDinosaur("Brachiosaurus");
park3.displayAll();
console.log(`Łącznie: ${park3.getCount()}`);
// ===========================================
// 7. PROBLEM: METODA JAKO CALLBACK
// ===========================================
console.log("\n=== 7. Problem: metoda jako callback ===");
const securitySystem = {
level: "HIGH",
checkSecurity: function() {
console.log(`Poziom zabezpieczeń: ${this.level}`);
}
};
// PROBLEM: this zostanie utracony
setTimeout(securitySystem.checkSecurity, 100); // this.level = undefined
// ROZWIĄZANIE 1: Arrow function wrapper
setTimeout(() => {
securitySystem.checkSecurity();
}, 150);
// ROZWIĄZANIE 2: bind()
setTimeout(securitySystem.checkSecurity.bind(securitySystem), 200);
// ===========================================
// 8. PRZYKŁAD KOMPLEKSOWY
// ===========================================
console.log("\n=== 8. System zarządzania parkiem - przykład kompleksowy ===");
class JurassicParkManagement {
constructor(parkName) {
this.parkName = parkName;
this.dinosaurs = [];
this.visitors = 0;
this.status = "CLOSED";
}
openPark() {
this.status = "OPEN";
console.log(`\n${this.parkName} - Park otwarty`);
}
closePark() {
this.status = "CLOSED";
console.log(`\n${this.parkName} - Park zamknięty`);
}
addDinosaur(name, species, sector) {
const dino = { name, species, sector, health: 100 };
this.dinosaurs.push(dino);
console.log(`Dodano ${name} (${species}) do sektora ${sector}`);
}
addVisitors(count) {
this.visitors += count;
console.log(`Dodano ${count} odwiedzających. Łącznie: ${this.visitors}`);
}
checkDinosaur(name) {
const dino = this.dinosaurs.find(d => d.name === name);
if (dino) {
console.log(`\nSprawdzenie ${name}:`);
console.log(` Gatunek: ${dino.species}`);
console.log(` Sektor: ${dino.sector}`);
console.log(` Zdrowie: ${dino.health}%`);
} else {
console.log(`Nie znaleziono dinozaura: ${name}`);
}
}
getDailyReport() {
console.log(`\nRAPORT DZIENNY - ${this.parkName}`);
console.log("=".repeat(50));
console.log(`Status: ${this.status}`);
console.log(`Dinozaury: ${this.dinosaurs.length}`);
console.log(`Odwiedzający: ${this.visitors}`);
if (this.dinosaurs.length > 0) {
console.log("\nLista dinozaurów:");
this.dinosaurs.forEach((dino, i) => {
console.log(` ${i + 1}. ${dino.name} (${dino.species}) - Sektor ${dino.sector}`);
});
}
}
// Metoda używająca setTimeout z arrow function
scheduleFeeding(dinoName, delay = 1000) {
console.log(`\n⏰ Zaplanowano karmienie ${dinoName} za ${delay}ms`);
setTimeout(() => {
const dino = this.dinosaurs.find(d => d.name === dinoName);
if (dino) {
console.log(`Karmienie ${dinoName} w ${this.parkName}`);
dino.health = Math.min(100, dino.health + 10);
}
}, delay);
}
}
// Demonstracja systemu
const management = new JurassicParkManagement("Isla Nublar");
management.openPark();
management.addDinosaur("Rexy", "Tyrannosaurus Rex", "A");
management.addDinosaur("Blue", "Velociraptor", "B");
management.addDinosaur("Trike", "Triceratops", "C");
management.addVisitors(500);
management.addVisitors(300);
management.checkDinosaur("Blue");
management.getDailyReport();
management.scheduleFeeding("Rexy", 500);
management.scheduleFeeding("Blue", 600);
setTimeout(() => {
console.log("\n--- Po karmieniu ---");
management.checkDinosaur("Rexy");
management.checkDinosaur("Blue");
management.closePark();
console.log("\nGratulacje! Opanowałeś słowo kluczowe 'this'!");
}, 800);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. Co oznacza słowo kluczowe 'this' w JavaScript?
2. Na co wskazuje 'this' wewnątrz metody obiektu w JavaScript?
3. Jak zachowuje się 'this' w funkcjach strzałkowych (arrow functions)?
4. W jakim kontekście 'this' wskazuje na nowo tworzony obiekt?