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

Słowo kluczowe this w JavaScript

13 min czytania ·
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:

  1. W kontekście globalnym
  2. Jako metoda obiektu
  3. Jako konstruktor
  4. Za pomocą metod call(), apply() lub bind()
  5. 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:

  1. 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}`);
    });
  }
};
  1. Zachowaj referencję do this w 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}`);
    });
  }
};
  1. 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 blueTracker

Rozwiązania:

  1. Użyj funkcji strzałkowej:
setTimeout(() => blueTracker.startTracking(), 1000);
  1. 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:

  1. W globalnym kontekście: this to window w przeglądarce i module.exports ({}) w pliku Node.js; w zwykłej funkcji poza trybem ścisłym - obiekt globalny (globalThis).

  2. W metodzie obiektu: this odnosi się do obiektu, który wywołał metodę.

  3. W konstruktorze: this odnosi się do nowo tworzonego obiektu.

  4. W funkcjach strzałkowych: this jest dziedziczone z otaczającego zakresu leksykalnego.

  5. Przy użyciu call/apply/bind: this jest jawnie określone przez programistę.

Najlepsze praktyki:

  1. Używaj funkcji strzałkowych dla funkcji zwrotnych (callbacks) i funkcji zagnieżdżonych, aby zachować kontekst this.

  2. Używaj metod call(), apply() lub bind(), gdy potrzebujesz jawnie kontrolować wartość this.

  3. Unikaj tworzenia metod w konstruktorach, zamiast tego dodawaj je do prototypu, aby uniknąć duplikacji kodu.

  4. Pamiętaj, że this jest ustalane podczas wywoływania funkcji, a nie podczas jej definiowania.

  5. 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. 1. Co oznacza słowo kluczowe 'this' w JavaScript?

  2. 2. Na co wskazuje 'this' wewnątrz metody obiektu w JavaScript?

  3. 3. Jak zachowuje się 'this' w funkcjach strzałkowych (arrow functions)?

  4. 4. W jakim kontekście 'this' wskazuje na nowo tworzony obiekt?

  1. PytanieKontekst this w JavaScript
  2. PytanieWartość this w metodzie obiektu
  3. Pytaniethis w arrow functions
  4. PytanieKontekst this w konstruktorze

Przydatne artykuły