Kurs JavaScript i TypeScript · Moduł 2: Funkcje, tablice i obiekty
Właściwości i metody obiektów
W tej lekcji9
W systemie zarządzania Parkiem Jurajskim, właściwości i metody obiektów są kluczowe dla modelowania i kontrolowania zachowania różnych elementów naszego kompleksu. W tej lekcji przyjrzymy się bliżej właściwościom i metodom obiektów JavaScript, poznając zaawansowane techniki, które pomagają nam utrzymać nasz park i jego mieszkańców w idealnym stanie.
Deskryptory właściwości
W JavaScript każda właściwość obiektu ma nie tylko wartość, ale również atrybuty kontrolujące, jak ta właściwość może być używana. Te atrybuty to tzw. deskryptory właściwości.
const dinosaur = {
name: "Blue"
};
// Pobieranie deskryptora właściwości
const descriptor = Object.getOwnPropertyDescriptor(dinosaur, "name");
console.log(descriptor);
// Wynik: { value: "Blue", writable: true, enumerable: true, configurable: true }Deskryptor właściwości zawiera następujące pola:
- value: aktualna wartość właściwości
- writable: czy właściwość może być zmieniona
- enumerable: czy właściwość pojawia się podczas iteracji (np. w pętli for...in)
- configurable: czy deskryptor może być zmieniony i czy właściwość może być usunięta
Definiowanie właściwości z deskryptorami
Możemy zdefiniować nowe właściwości z określonymi deskryptorami za pomocą Object.defineProperty():
const velociraptor = {};
// Definiujemy właściwość "species" z określonymi deskryptorami
Object.defineProperty(velociraptor, "species", {
value: "Velociraptor",
writable: false, // Nie możemy zmienić wartości
enumerable: true, // Pojawi się podczas iteracji
configurable: false // Nie możemy zmienić deskryptora ani usunąć właściwości
});
console.log(velociraptor.species); // "Velociraptor"
// Próba zmiany nie zadziała (w trybie ścisłym rzuci błąd)
velociraptor.species = "Tyrannosaurus";
console.log(velociraptor.species); // Nadal "Velociraptor"
// Próba usunięcia nie zadziała
delete velociraptor.species; // Zwróci false
console.log(velociraptor.species); // Nadal "Velociraptor"Możemy również zdefiniować wiele właściwości naraz:
const triceratops = {};
Object.defineProperties(triceratops, {
species: {
value: "Triceratops",
writable: false
},
diet: {
value: "herbivore",
writable: false
},
age: {
value: 5,
writable: true // Wiek może się zmieniać
}
});
console.log(triceratops.species); // "Triceratops"
console.log(triceratops.diet); // "herbivore"
console.log(triceratops.age); // 5
triceratops.age = 6;
console.log(triceratops.age); // 6Gettery i settery
Gettery i settery to specjalne metody, które pozwalają na kontrolę dostępu do właściwości obiektu.
const dinosaur = {
_health: 100, // Konwencja podkreślenia wskazuje, że to prywatna właściwość
// Getter - wykonuje się, gdy próbujemy odczytać właściwość health
get health() {
console.log("Odczytywanie poziomu zdrowia");
return this._health;
},
// Setter - wykonuje się, gdy próbujemy przypisać wartość do właściwości health
set health(value) {
if (value < 0) {
console.log("Ostrzeżenie: Próba ustawienia zdrowia poniżej 0");
this._health = 0;
} else if (value > 100) {
console.log("Ostrzeżenie: Próba ustawienia zdrowia powyżej 100");
this._health = 100;
} else {
console.log(`Ustawianie poziomu zdrowia na ${value}`);
this._health = value;
}
}
};
console.log(dinosaur.health); // Uruchamia getter, wynik: 100
dinosaur.health = 80; // Uruchamia setter
console.log(dinosaur.health); // 80
dinosaur.health = 150; // "Ostrzeżenie: Próba ustawienia zdrowia powyżej 100"
console.log(dinosaur.health); // 100
dinosaur.health = -20; // "Ostrzeżenie: Próba ustawienia zdrowia poniżej 0"
console.log(dinosaur.health); // 0Gettery i settery możemy również zdefiniować przy użyciu Object.defineProperty():
const dinosaur = {
_name: "Rex",
_species: "Tyrannosaurus"
};
Object.defineProperty(dinosaur, "fullName", {
get: function() {
return `${this._name} the ${this._species}`;
},
set: function(value) {
// Zakładamy, że value ma format "Nazwa the Gatunek"
const parts = value.split(" the ");
if (parts.length === 2) {
this._name = parts[0];
this._species = parts[1];
} else {
console.log("Nieprawidłowy format. Użyj: 'Nazwa the Gatunek'");
}
},
enumerable: true,
configurable: true
});
console.log(dinosaur.fullName); // "Rex the Tyrannosaurus"
dinosaur.fullName = "Blue the Velociraptor";
console.log(dinosaur._name); // "Blue"
console.log(dinosaur._species); // "Velociraptor"Metody obiektów i ich zaawansowane właściwości
Wiązanie this - metoda bind
Słowo kluczowe this w metodach odnosi się do obiektu, na którym metoda jest wywoływana. Jednak w niektórych przypadkach (np. gdy przekazujemy metodę jako callback) możemy stracić kontekst this. Metoda bind pozwala na jawne ustawienie wartości this.
const rex = {
name: "Rex",
makeSound: function() {
console.log(`${this.name} ryczy głośno!`);
}
};
// Działanie normalne
rex.makeSound(); // "Rex ryczy głośno!"
// Problematyczne użycie - utrata kontekstu this
const rexSound = rex.makeSound;
// rexSound(); // Błąd: this.name jest undefined
// Rozwiązanie - użycie bind, aby ustawić wartość this
const boundRexSound = rex.makeSound.bind(rex);
boundRexSound(); // "Rex ryczy głośno!"
// Możemy również ustawić this na inny obiekt
const blue = { name: "Blue" };
const blueSound = rex.makeSound.bind(blue);
blueSound(); // "Blue ryczy głośno!"Metody call i apply
Metody call i apply pozwalają na wywołanie funkcji z określoną wartością this i argumentami:
function attack(target, damage) {
console.log(`${this.name} atakuje ${target} i zadaje ${damage} obrażeń!`);
}
const trex = { name: "Tyrannosaurus Rex" };
const raptor = { name: "Velociraptor" };
// Używamy call z jawnie przekazywanymi argumentami
attack.call(trex, "Triceratops", 50);
// "Tyrannosaurus Rex atakuje Triceratops i zadaje 50 obrażeń!"
// Używamy apply z argumentami w tablicy
attack.apply(raptor, ["Gallimimus", 30]);
// "Velociraptor atakuje Gallimimus i zadaje 30 obrażeń!"Właściwości obiektów jako symbole
Symbole zapewniają unikalne identyfikatory, które mogą być używane jako klucze właściwości obiektów. Są one szczególnie przydatne do tworzenia "prywatnych" właściwości lub do rozszerzania obiektów bez ryzyka kolizji nazw.
// Tworzenie symboli
const healthSymbol = Symbol('health');
const nameSymbol = Symbol('name');
const dinosaur = {
[nameSymbol]: "Blue",
[healthSymbol]: 100,
species: "Velociraptor"
};
console.log(dinosaur[nameSymbol]); // "Blue"
console.log(dinosaur[healthSymbol]); // 100
// Symbole nie są widoczne w pętlach for...in
for (let key in dinosaur) {
console.log(key); // Tylko "species", bez nameSymbol i healthSymbol
}
// Ani w Object.keys()
console.log(Object.keys(dinosaur)); // ["species"]
// Ale można je uzyskać za pomocą Object.getOwnPropertySymbols()
console.log(Object.getOwnPropertySymbols(dinosaur)); // [Symbol(name), Symbol(health)]Dobrze znane symbole
JavaScript definiuje kilka "dobrze znanych symboli", które pozwalają klasom na dostosowanie swojego zachowania. Najczęściej używanym jest Symbol.iterator, który umożliwia obiektom bycie iterowalnymi.
// Tworzymy obiekt DinosaurPack, który będzie iterowalny
class DinosaurPack {
constructor() {
this.dinosaurs = [];
}
addDinosaur(name, species) {
this.dinosaurs.push({ name, species });
}
// Implementacja iterowalności
[Symbol.iterator]() {
let index = 0;
const dinosaurs = this.dinosaurs;
return {
next: function() {
if (index < dinosaurs.length) {
return { value: dinosaurs[index++], done: false };
} else {
return { done: true };
}
}
};
}
}
const pack = new DinosaurPack();
pack.addDinosaur("Blue", "Velociraptor");
pack.addDinosaur("Delta", "Velociraptor");
pack.addDinosaur("Echo", "Velociraptor");
pack.addDinosaur("Charlie", "Velociraptor");
// Teraz możemy iterować po naszym obiekcie
for (const dino of pack) {
console.log(`${dino.name} to ${dino.species}`);
}
// Wynik:
// "Blue to Velociraptor"
// "Delta to Velociraptor"
// "Echo to Velociraptor"
// "Charlie to Velociraptor"Zamrożenie, uszczelnienie i zapobieganie rozszerzaniu obiektów
JavaScript oferuje trzy metody do kontrolowania modyfikowalności obiektów:
Object.freeze()
Zamraża obiekt (płytko: obiekty zagnieżdżone nadal można zmieniać) - nie można zmieniać istniejących właściwości ani dodawać nowych.
const securityProtocol = {
level: "Maximum",
status: "Active",
lastUpdated: "2023-01-15"
};
// Zamrażamy obiekt
Object.freeze(securityProtocol);
// Próby modyfikacji nie zadziałają
securityProtocol.level = "Minimum"; // Nie zmieni się
securityProtocol.newProperty = "Value"; // Nie zostanie dodane
console.log(securityProtocol.level); // Nadal "Maximum"
console.log(securityProtocol.newProperty); // undefined
console.log(Object.isFrozen(securityProtocol)); // trueObject.seal()
Uszczelnia obiekt - można modyfikować istniejące właściwości, ale nie można dodawać nowych ani usuwać istniejących.
const dinoStats = {
health: 100,
hunger: 50
};
// Uszczelniamy obiekt
Object.seal(dinoStats);
// Możemy modyfikować istniejące właściwości
dinoStats.health = 80;
console.log(dinoStats.health); // 80
// Ale nie możemy dodawać nowych
dinoStats.happiness = 90; // Nie zadziała
console.log(dinoStats.happiness); // undefined
// Ani usuwać istniejących
delete dinoStats.hunger; // Nie zadziała
console.log(dinoStats.hunger); // Nadal 50
console.log(Object.isSealed(dinoStats)); // trueObject.preventExtensions()
Zapobiega rozszerzaniu obiektu - nie można dodawać nowych właściwości, ale można modyfikować i usuwać istniejące.
const dinosaur = {
name: "Blue",
species: "Velociraptor"
};
// Zapobiegamy rozszerzaniu
Object.preventExtensions(dinosaur);
// Nie możemy dodawać nowych właściwości
dinosaur.age = 4; // Nie zadziała
console.log(dinosaur.age); // undefined
// Ale możemy modyfikować istniejące
dinosaur.name = "Delta";
console.log(dinosaur.name); // "Delta"
// I usuwać istniejące
delete dinosaur.species;
console.log(dinosaur.species); // undefined
console.log(Object.isExtensible(dinosaur)); // falseObiekt Proxy
Obiekt Proxy pozwala na przechwytywanie i dostosowywanie podstawowych operacji na obiektach.
const dinosaur = {
name: "Blue",
species: "Velociraptor",
health: 100,
hunger: 50,
aggressionLevel: 8
};
// Tworzymy proxy dla obiektu dinosaur
const monitoredDinosaur = new Proxy(dinosaur, {
// Przechwytujemy operację pobierania właściwości
get: function(target, prop, receiver) {
console.log(`Odczytywanie właściwości: ${prop}`);
return Reflect.get(target, prop, receiver);
},
// Przechwytujemy operację ustawiania właściwości
set: function(target, prop, value, receiver) {
console.log(`Ustawianie ${prop} na ${value}`);
// Dodajemy walidację dla niektórych właściwości
if (prop === 'health') {
if (value < 0) value = 0;
if (value > 100) value = 100;
// Logowanie zmiany zdrowia
const oldValue = target[prop];
const change = value - oldValue;
console.log(`Zmiana zdrowia: ${change > 0 ? '+' : ''}${change}%`);
// Sprawdzanie czy dinozaur nie jest poważnie ranny
if (value < 20 && oldValue >= 20) {
console.log("ALARM: Dinozaur jest poważnie ranny!");
}
}
if (prop === 'aggressionLevel') {
if (value > 7) {
console.log("UWAGA: Wysoki poziom agresji - należy zwiększyć środki bezpieczeństwa!");
}
}
return Reflect.set(target, prop, value, receiver);
},
// Przechwytujemy operację usuwania właściwości
deleteProperty: function(target, prop) {
console.log(`Próba usunięcia ${prop} - operacja zabroniona dla bezpieczeństwa danych`);
return false; // Nie pozwalamy na usuwanie właściwości
}
});
// Testujemy nasze proxy
console.log(monitoredDinosaur.name); // "Odczytywanie właściwości: name", "Blue"
monitoredDinosaur.health = 90; // "Ustawianie health na 90", "Zmiana zdrowia: -10%"
monitoredDinosaur.health = 15; // "Ustawianie health na 15", "Zmiana zdrowia: -75%", "ALARM: Dinozaur jest poważnie ranny!"
monitoredDinosaur.aggressionLevel = 9; // "Ustawianie aggressionLevel na 9", "UWAGA: Wysoki poziom agresji..."
delete monitoredDinosaur.hunger; // "Próba usunięcia hunger - operacja zabroniona dla bezpieczeństwa danych"Praktyczne zastosowanie: System monitorowania zdrowia dinozaurów
Połączmy kilka poznanych technik, aby stworzyć zaawansowany system monitorowania zdrowia dinozaurów w naszym parku:
class DinosaurHealthMonitor {
constructor() {
this.dinosaurs = new Map();
this.alarmThreshold = 30;
this.criticalThreshold = 15;
this.lastCheckTime = null;
}
// Dodajemy dinozaura do systemu monitorowania
addDinosaur(id, name, species) {
if (this.dinosaurs.has(id)) {
console.log(`Dinozaur o ID ${id} już istnieje w systemie.`);
return false;
}
const dinosaurData = {
id,
name,
species,
_health: 100,
_lastFed: new Date(),
_status: "Healthy",
// Używamy gettera i settera dla zdrowia
get health() {
return this._health;
},
set health(value) {
const oldHealth = this._health;
this._health = Math.max(0, Math.min(100, value)); // Ograniczenie do zakresu 0-100
// Aktualizacja statusu na podstawie zdrowia
if (this._health === 0) {
this._status = "Critical - Emergency Response Required";
} else if (this._health < 15) {
this._status = "Critical";
} else if (this._health < 30) {
this._status = "Poor - Medical Attention Required";
} else if (this._health < 60) {
this._status = "Fair";
} else if (this._health < 90) {
this._status = "Good";
} else {
this._status = "Excellent";
}
return this._health;
},
// Metoda karmienia dinozaura
feed() {
const now = new Date();
const hoursSinceLastFed = (now - this._lastFed) / (1000 * 60 * 60);
// Efekt karmienia zależy od tego, jak dawno dinozaur był ostatnio karmiony
if (hoursSinceLastFed < 1) {
console.log(`${this.name} nie jest głodny (karmiony mniej niż godzinę temu).`);
return false;
} else {
const healthGain = Math.min(10, hoursSinceLastFed * 2); // Maksymalnie 10 punktów zdrowia
this.health += healthGain;
this._lastFed = now;
console.log(`${this.name} został nakarmiony. +${healthGain.toFixed(1)} do zdrowia. Aktualny poziom: ${this.health}%`);
return true;
}
}
};
// Używamy Object.seal, aby zapobiec dodawaniu nowych właściwości
Object.seal(dinosaurData);
// Dodajemy dinozaura do mapy
this.dinosaurs.set(id, dinosaurData);
console.log(`Dodano dinozaura ${name} (${species}) do systemu monitorowania zdrowia.`);
return true;
}
// Pobieranie informacji o dinozaurze
getDinosaurInfo(id) {
if (!this.dinosaurs.has(id)) {
return `Dinozaur o ID ${id} nie istnieje w systemie.`;
}
const dino = this.dinosaurs.get(id);
return {
id: dino.id,
name: dino.name,
species: dino.species,
health: dino.health,
status: dino._status,
lastFed: dino._lastFed
};
}
// Metoda do symulacji upływu czasu, która obniża zdrowie dinozaurów
simulateTimePass(hours) {
console.log(`Symulacja upływu ${hours} godzin...`);
this.dinosaurs.forEach(dino => {
// Obniżenie zdrowia - tempo zależy od gatunku
let healthReduction = hours;
if (dino.species.toLowerCase().includes('tyrannosaurus')) {
healthReduction *= 1.5; // Tyrannosaurus traci zdrowie szybciej
} else if (dino.species.toLowerCase().includes('velociraptor')) {
healthReduction *= 1.2; // Velociraptory też dość szybko
}
const newHealth = dino.health - healthReduction;
dino.health = newHealth;
console.log(`${dino.name}: Zdrowie zmniejszone o ${healthReduction.toFixed(1)} do ${dino.health}% (${dino._status})`);
});
this.lastCheckTime = new Date();
this.checkAlarms();
}
// Sprawdzanie alarmów zdrowotnych
checkAlarms() {
console.log("Sprawdzanie alarmów zdrowotnych...");
const criticalDinos = [];
const alarmDinos = [];
this.dinosaurs.forEach(dino => {
if (dino.health <= this.criticalThreshold) {
criticalDinos.push(dino);
} else if (dino.health <= this.alarmThreshold) {
alarmDinos.push(dino);
}
});
if (criticalDinos.length > 0) {
console.log("=== KRYTYCZNY STAN ZDROWIA ===");
criticalDinos.forEach(dino => {
console.log(`- ${dino.name} (${dino.species}): ${dino.health}% - WYMAGA NATYCHMIASTOWEJ INTERWENCJI!`);
});
}
if (alarmDinos.length > 0) {
console.log("=== ALARM ZDROWOTNY ===");
alarmDinos.forEach(dino => {
console.log(`- ${dino.name} (${dino.species}): ${dino.health}% - Wymaga opieki weterynaryjnej`);
});
}
if (criticalDinos.length === 0 && alarmDinos.length === 0) {
console.log("Wszystkie dinozaury są w dobrej kondycji zdrowotnej.");
}
}
// Generowanie raportu dla wszystkich dinozaurów
generateHealthReport() {
const now = new Date();
let report = `=== RAPORT ZDROWIA DINOZAURÓW (wygenerowany: ${now.toLocaleString()}) ===\n`;
if (this.dinosaurs.size === 0) {
report += "Brak dinozaurów w systemie monitorowania.\n";
} else {
// Sortowanie dinozaurów według poziomu zdrowia (od najniższego)
const sortedDinos = [...this.dinosaurs.values()].sort((a, b) => a.health - b.health);
sortedDinos.forEach(dino => {
report += `${dino.name} (${dino.species})\n`;
report += ` Zdrowie: ${dino.health}% (${dino._status})\n`;
report += ` Ostatnio karmiony: ${dino._lastFed.toLocaleString()}\n`;
// Dodajemy rekomendacje
if (dino.health < this.criticalThreshold) {
report += " REKOMENDACJA: Natychmiastowa interwencja weterynaryjna! Przeniesienie do ośrodka intensywnej opieki.\n";
} else if (dino.health < this.alarmThreshold) {
report += " REKOMENDACJA: Zwiększona częstotliwość karmienia i kontroli weterynaryjnej.\n";
}
report += "\n";
});
}
return report;
}
}
// Przykład użycia
const healthMonitor = new DinosaurHealthMonitor();
// Dodajemy kilka dinozaurów
healthMonitor.addDinosaur("TRX-01", "Rex", "Tyrannosaurus Rex");
healthMonitor.addDinosaur("VEL-01", "Blue", "Velociraptor");
healthMonitor.addDinosaur("TRI-01", "Trixie", "Triceratops");
healthMonitor.addDinosaur("BRACH-01", "Bronty", "Brachiosaurus");
// Generujemy raport początkowy
console.log(healthMonitor.generateHealthReport());
// Symulujemy upływ czasu
healthMonitor.simulateTimePass(24); // 24 godziny
// Karmimy niektóre dinozaury
const rex = healthMonitor.dinosaurs.get("TRX-01");
const blue = healthMonitor.dinosaurs.get("VEL-01");
rex.feed();
blue.feed();
// Symulujemy kolejny upływ czasu
healthMonitor.simulateTimePass(48); // 48 godzin
// Generujemy końcowy raport
console.log(healthMonitor.generateHealthReport());Podsumowanie
W tej lekcji poznaliśmy zaawansowane właściwości i metody obiektów JavaScript:
- Deskryptory właściwości - pozwalają na precyzyjną kontrolę nad atrybutami właściwości
- Gettery i settery - umożliwiają wykonanie kodu podczas odczytu lub zapisu właściwości
- Wiązanie this - metody bind, call i apply pomagają w kontrolowaniu kontekstu funkcji
- Symbole - zapewniają unikalne identyfikatory dla właściwości obiektów
- Zamrażanie obiektów - metody freeze, seal i preventExtensions pozwalają ograniczyć modyfikowalność obiektów
- Proxy - pozwala na przechwytywanie i dostosowywanie podstawowych operacji na obiektach
Te techniki są niezbędne przy tworzeniu złożonych systemów, takich jak nasz system monitorowania zdrowia dinozaurów w Parku Jurajskim. Pozwalają na tworzenie bardziej niezawodnych, bezpiecznych i eleganckich rozwiązań programistycznych.
Kod do tej lekcji: index.js
// Właściwości i metody obiektów - Park Jurajski
console.log("Właściwości i Metody Obiektów");
console.log("Zaawansowane operacje na obiektach\n");
// ===========================================
// 1. DOSTĘP DO WŁAŚCIWOŚCI
// ===========================================
console.log("=== 1. Dostęp do właściwości ===");
const dinosaur = {
name: "T-Rex",
species: "Tyrannosaurus Rex",
age: 8,
"sector-id": "A-7", // Właściwość z myślnikiem
weight: 8000
};
// Notacja kropkowa
console.log("\nNotacja kropkowa:");
console.log(` name: ${dinosaur.name}`);
console.log(` age: ${dinosaur.age}`);
// Notacja nawiasowa
console.log("\nNotacja nawiasowa:");
console.log(` ['species']: ${dinosaur['species']}`);
console.log(` ['sector-id']: ${dinosaur['sector-id']}`); // Wymagane dla myślników
// Dynamiczny dostęp
const prop = "weight";
console.log(`\nDynamiczny dostęp [${prop}]: ${dinosaur[prop]}`);
// ===========================================
// 2. DODAWANIE I MODYFIKOWANIE WŁAŚCIWOŚCI
// ===========================================
console.log("\n=== 2. Dodawanie i modyfikowanie ===");
const dino = {
name: "Blue",
species: "Velociraptor"
};
console.log("\nPoczątkowo:", dino);
// Dodawanie nowych właściwości
dino.age = 5;
dino.weight = 80;
dino["sector"] = "B";
console.log("Po dodaniu:", dino);
// Modyfikowanie istniejących
dino.age = 6;
dino.weight = 85;
console.log("Po modyfikacji:", dino);
// ===========================================
// 3. USUWANIE WŁAŚCIWOŚCI
// ===========================================
console.log("\n=== 3. Usuwanie właściwości ===");
const tempDino = {
name: "Charlie",
species: "Velociraptor",
tempId: 12345,
debugMode: true
};
console.log("\nPrzed usunięciem:", tempDino);
delete tempDino.tempId;
delete tempDino.debugMode;
console.log("Po usunięciu:", tempDino);
// ===========================================
// 4. SPRAWDZANIE ISTNIENIA WŁAŚCIWOŚCI
// ===========================================
console.log("\n=== 4. Sprawdzanie istnienia ===");
const checkDino = {
name: "Rexy",
age: 8,
sector: null
};
// Operator 'in'
console.log("\nOperator 'in':");
console.log(` 'name' in checkDino: ${'name' in checkDino}`);
console.log(` 'weight' in checkDino: ${'weight' in checkDino}`);
console.log(` 'sector' in checkDino: ${'sector' in checkDino}`); // true mimo null!
// hasOwnProperty()
console.log("\nhasOwnProperty():");
console.log(` hasOwnProperty('name'): ${checkDino.hasOwnProperty('name')}`);
console.log(` hasOwnProperty('toString'): ${checkDino.hasOwnProperty('toString')}`); // false (odziedziczona)
// undefined check
console.log("\nSprawdzanie undefined:");
console.log(` name !== undefined: ${checkDino.name !== undefined}`);
console.log(` weight !== undefined: ${checkDino.weight !== undefined}`);
// ===========================================
// 5. ITERACJA PO WŁAŚCIWOŚCIACH
// ===========================================
console.log("\n=== 5. Iteracja po właściwościach ===");
const iterDino = {
name: "Trike",
species: "Triceratops",
age: 7,
weight: 9000,
sector: "C"
};
// for...in
console.log("\nfor...in:");
for (const key in iterDino) {
console.log(` ${key}: ${iterDino[key]}`);
}
// Object.keys()
console.log("\nObject.keys():");
const keys = Object.keys(iterDino);
console.log(` Klucze: ${keys.join(", ")}`);
// Object.values()
console.log("\nObject.values():");
const values = Object.values(iterDino);
console.log(` Wartości: ${values.join(", ")}`);
// Object.entries()
console.log("\nObject.entries():");
Object.entries(iterDino).forEach(([key, value]) => {
console.log(` ${key} => ${value}`);
});
// ===========================================
// 6. METODY OBIEKTÓW
// ===========================================
console.log("\n=== 6. Metody obiektów ===");
const methodDino = {
name: "Stego",
species: "Stegosaurus",
health: 85,
// Metoda tradycyjna
getInfo: function() {
return `${this.name} (${this.species})`;
},
// Metoda skrócona (ES6)
roar() {
return `${this.name} says: ROAARRR!`;
},
// Metoda z parametrami
updateHealth(change) {
this.health += change;
if (this.health > 100) this.health = 100;
if (this.health < 0) this.health = 0;
return `Zdrowie: ${this.health}%`;
},
// Metoda zwracająca obiekt
getStats() {
return {
name: this.name,
health: this.health,
status: this.health >= 80 ? "Zdrowy" : "Wymaga uwagi"
};
}
};
console.log("\n", methodDino.getInfo());
console.log(" ", methodDino.roar());
console.log(" ", methodDino.updateHealth(10));
console.log(" Stats:", methodDino.getStats());
// ===========================================
// 7. THIS W METODACH
// ===========================================
console.log("\n=== 7. Kontekst 'this' w metodach ===");
const thisDino = {
name: "Brachio",
sector: "D",
showInfo() {
console.log(`\n${this.name} w sektorze ${this.sector}`);
},
// Problem z zagnieżdżoną funkcją
showWithTraditional() {
console.log(`\n${this.name}:`);
["Karmienie", "Badanie", "Czyszczenie"].forEach(function(task) {
// this tutaj NIE odnosi się do thisDino!
console.log(` - ${task}`); // Nie możemy użyć this.name
});
},
// Rozwiązanie z arrow function
showWithArrow() {
console.log(`\n${this.name}:`);
["Karmienie", "Badanie", "Czyszczenie"].forEach(task => {
console.log(` - ${task} dla ${this.name}`); // this działa!
});
}
};
thisDino.showInfo();
thisDino.showWithTraditional();
thisDino.showWithArrow();
// ===========================================
// 8. COMPUTED PROPERTY NAMES
// ===========================================
console.log("\n=== 8. Computed property names ===");
const propName = "species";
const propValue = "Velociraptor";
const sectorNumber = 7;
const computedDino = {
name: "Echo",
[propName]: propValue, // Obliczana nazwa właściwości
[`sector-${sectorNumber}`]: true,
[`health_${Date.now()}`]: 95
};
console.log("\nObiekt z obliczanymi nazwami:");
console.log(computedDino);
// ===========================================
// 9. PROPERTY DESCRIPTORS
// ===========================================
console.log("\n=== 9. Property descriptors ===");
const descriptorDino = {};
// Definiowanie właściwości z deskryptorami
Object.defineProperty(descriptorDino, 'name', {
value: "Rex",
writable: true,
enumerable: true,
configurable: true
});
Object.defineProperty(descriptorDino, 'id', {
value: 12345,
writable: false, // Tylko do odczytu
enumerable: false, // Nie pojawi się w for...in
configurable: false // Nie można usunąć ani zmienić deskryptora
});
console.log("\nWłaściwości:");
console.log(` name: ${descriptorDino.name}`);
console.log(` id: ${descriptorDino.id}`);
console.log("\nPróba modyfikacji:");
descriptorDino.name = "Rexy"; // Zadziała
console.log(` name po zmianie: ${descriptorDino.name}`);
descriptorDino.id = 99999; // Nie zadziała (writable: false)
console.log(` id po próbie zmiany: ${descriptorDino.id}`);
console.log("\nfor...in (id nie pojawi się):");
for (const key in descriptorDino) {
console.log(` ${key}: ${descriptorDino[key]}`);
}
// ===========================================
// 10. PRZYKŁAD KOMPLEKSOWY
// ===========================================
console.log("\n=== 10. System zarządzania dinozaurem - przykład kompleksowy ===");
class DinosaurManager {
constructor(name, species) {
// Właściwości podstawowe
this._name = name;
this._species = species;
this._health = 100;
this._fed = false;
this._lastFed = null;
this._activities = [];
// Właściwości obliczane
Object.defineProperty(this, 'id', {
value: `DINO-${Date.now()}`,
writable: false,
enumerable: true
});
}
// Gettery i settery
get name() {
return this._name;
}
get species() {
return this._species;
}
get health() {
return this._health;
}
set health(value) {
if (value < 0) value = 0;
if (value > 100) value = 100;
const oldHealth = this._health;
this._health = value;
this.logActivity(`Zdrowie zmienione z ${oldHealth}% na ${value}%`);
}
get status() {
if (this._health >= 80) return "Doskonały";
if (this._health >= 50) return "Dobry";
if (this._health >= 20) return "Słaby";
return "Krytyczny";
}
get needsFeeding() {
if (!this._lastFed) return true;
const hoursSinceLastFed = (Date.now() - this._lastFed) / (1000 * 60 * 60);
return hoursSinceLastFed > 8;
}
// Metody akcji
feed() {
this._fed = true;
this._lastFed = Date.now();
this.health += 5;
this.logActivity("Nakarmiony");
return `${this._name} został nakarmiony`;
}
heal(amount) {
this.health += amount;
this.logActivity(`Leczony (+${amount}% zdrowia)`);
return `${this._name} wyleczony o ${amount}%`;
}
exercise() {
this.health -= 5;
this.logActivity("Ćwiczenia");
return `${this._name} wykonał ćwiczenia`;
}
// Metody pomocnicze
logActivity(activity) {
this._activities.push({
activity,
timestamp: new Date().toISOString(),
health: this._health
});
}
getActivityLog(limit = 5) {
return this._activities.slice(-limit);
}
getInfo() {
return {
id: this.id,
name: this._name,
species: this._species,
health: this._health,
status: this.status,
fed: this._fed,
needsFeeding: this.needsFeeding,
activitiesCount: this._activities.length
};
}
displayReport() {
console.log(`\n==================================================`);
console.log(`RAPORT DINOZAURA: ${this._name}`);
console.log("=".repeat(50));
const info = this.getInfo();
console.log(`ID: ${info.id}`);
console.log(`Gatunek: ${info.species}`);
console.log(`Zdrowie: ${info.health}% (${info.status})`);
console.log(`Nakarmiony: ${info.fed ? "Tak" : "Nie"}`);
console.log(`Wymaga karmienia: ${info.needsFeeding ? "Tak" : "Nie"}`);
console.log(`Liczba aktywności: ${info.activitiesCount}`);
const recentActivities = this.getActivityLog(5);
if (recentActivities.length > 0) {
console.log(`\nOstatnie aktywności:`);
recentActivities.forEach((act, i) => {
const time = new Date(act.timestamp).toLocaleTimeString();
console.log(` ${i + 1}. [${time}] ${act.activity} (zdrowie: ${act.health}%)`);
});
}
}
// Metoda statyczna
static compare(dino1, dino2) {
console.log(`\nPorównanie: ${dino1.name} vs ${dino2.name}`);
console.log(` Zdrowie: ${dino1.health}% vs ${dino2.health}%`);
console.log(` Status: ${dino1.status} vs ${dino2.status}`);
if (dino1.health > dino2.health) {
console.log(` ${dino1.name} jest zdrowszy`);
} else if (dino2.health > dino1.health) {
console.log(` ${dino2.name} jest zdrowszy`);
} else {
console.log(` Obaj mają takie samo zdrowie`);
}
}
}
// Demonstracja systemu
const rexy = new DinosaurManager("Rexy", "T-Rex");
const blue = new DinosaurManager("Blue", "Velociraptor");
console.log();
console.log(rexy.feed());
console.log(rexy.exercise());
console.log(rexy.heal(10));
console.log();
console.log(blue.feed());
console.log(blue.exercise());
console.log(blue.exercise());
rexy.displayReport();
blue.displayReport();
DinosaurManager.compare(rexy, blue);
console.log("\nGratulacje! Opanowałeś właściwości i metody obiektów!");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. Do czego służy Object.defineProperty() w JavaScript?
2. Do czego służą gettery (get) i settery (set) w obiektach JavaScript?
Zadania praktyczne w grze
- Klikanie w kolejności
Ułóż elementy definicji gettera w obiekcie: