6.1 Tworzenie obiektów
Obiekty są jednym z podstawowych typów danych w JavaScript i są szeroko używane do przechowywania i zarządzania danymi. Obiekt to kolekcja właściwości, gdzie każda właściwość składa się z klucza (nazwy) i wartości. W tym wykładzie omówimy tworzenie obiektów, a także dostęp do ich właściwości i metod.
1. Literał obiektu
Najczęstszym sposobem tworzenia obiektu w JavaScript jest użycie literału obiektu.
W tym przykładzie stworzyliśmy obiekt person z czterema właściwościami: name, age, isStudent i greet.
let person = {
name: 'John',
age: 30,
isStudent: false,
greet: function() {
return 'Hello!';
}
};
2. Konstruktor Object
Obiekty mogą być również tworzone za pomocą konstruktora Object().
Ten sposób jest równoważny z tworzeniem obiektu za pomocą literału obiektu, ale jest bardziej rozwlekły:
let person = new Object();
person.name = 'John';
person.age = 30;
person.isStudent = false;
person.greet = function() {
return 'Hello!';
};
3. Funkcja-konstruktor
Funkcja-konstruktor pozwala tworzyć wiele egzemplarzy obiektów z identycznymi właściwościami i metodami.
W tym przykładzie funkcja-konstruktor Person() jest używana do tworzenia obiektów john i jane z identycznymi właściwościami i metodami:
function Person(name, age, isStudent) {
this.name = name;
this.age = age;
this.isStudent = isStudent;
this.greet = function() {
return 'Hello!';
};
}
let john = new Person('John', 30, false);
let jane = new Person('Jane', 25, true);
4. Metoda Object.create()
Metoda Object.create() tworzy nowy obiekt i od razu przypisuje mu prototyp — inny obiekt, w którym nowy będzie szukał właściwości i metod, których sam nie ma.
W tym przykładzie obiekt john powstaje na podstawie prototypu personPrototype:
let personPrototype = {
greet: function() {
return 'Hello!';
}
};
let john = Object.create(personPrototype);
john.name = 'John';
john.age = 30;
john.isStudent = false;
console.log(john.name); // Wyświetli: John
console.log(john.greet()); // Wyświetli: Hello!
Warto zwrócić uwagę na ostatnią linię. Obiekt john nie ma własnej metody greet — zapisaliśmy w nim tylko name, age i isStudent. Mimo to john.greet() działa: przy odwołaniu do właściwości JavaScript szuka jej najpierw w samym obiekcie, a gdy jej tam nie znajdzie, wspina się do prototypu. Ta ścieżka wyszukiwania nazywa się łańcuchem prototypów.
Różnicę między właściwością własną a odziedziczoną łatwo zobaczyć:
console.log(john.hasOwnProperty('name')); // Wyświetli: true
console.log(john.hasOwnProperty('greet')); // Wyświetli: false
console.log('greet' in john); // Wyświetli: true
hasOwnProperty() odpowiada na pytanie „czy obiekt ma tę właściwość u siebie”, a operator in — „czy do właściwości można w ogóle dotrzeć, choćby przez łańcuch prototypów”. Stąd różne odpowiedzi dla greet.
Ważne: właściwości prototypu nie są kopiowane do nowego obiektu. personPrototype pozostaje osobnym obiektem, a john tylko się do niego odwołuje. Dzięki temu jeden prototyp może być współdzielony przez setki obiektów, a greet zajmuje pamięć tylko raz. Dla porównania: w funkcji konstruktora z przykładu 3 każdy utworzony obiekt dostawał własną kopię greet.
Drugi argument: właściwości z ustawieniami
Object.create() przyjmuje drugi, opcjonalny argument — obiekt opisujący właściwości, które trzeba utworzyć od razu. Definiuje się je nie zwykłą wartością, lecz deskryptorem — zestawem ustawień:
value— sama wartość właściwościwritable— czy wartość można zmieniać (domyślniefalse)enumerable— czy właściwość pojawia się wfor...iniObject.keys()(domyślniefalse)configurable— czy właściwość można usunąć lub zmienić jej ustawienia (domyślniefalse)get/set— getter i setter zamiast zwykłej wartości. Getter uruchamia się przy odczycie, setter przy zapisie
Wszystko razem:
let john = Object.create(personPrototype, {
name: {
value: 'John',
writable: true, // wartość można zmieniać
enumerable: true // właściwość widoczna w for...in
},
id: {
value: 1001,
writable: false, // tylko do odczytu
enumerable: true
},
info: {
enumerable: true,
get: function() { // getter: uruchamia się przy odczycie
return this.name + ' #' + this.id;
},
set: function(value) { // setter: uruchamia się przy zapisie
this.name = value;
}
}
});
console.log(john.info); // Wyświetli: John #1001
john.name = 'Johnny'; // zadziała
john.id = 2002; // po cichu nie zadziała
console.log(john.info); // Wyświetli: Johnny #1001
Uwaga: wszystkie trzy flagi mają domyślnie wartość false, więc przy korzystaniu z drugiego argumentu prawie zawsze trzeba je ustawić jawnie. Przypisanie do właściwości z writable: false w trybie zwykłym po cichu nie zadziała, a w trybie ścisłym ('use strict') rzuci TypeError.
Osobnym przydatnym przypadkiem jest Object.create(null). Taki obiekt nie ma prototypu w ogóle: ani toString(), ani hasOwnProperty(), ani innych odziedziczonych metod. To czyni z niego wygodny „czysty słownik”, w którym każdy klucz na pewno pochodzi od nas, a nie z Object.prototype.
6.2 Dostęp do właściwości i metod
1. Dostęp za pomocą kropki
Najczęstszym sposobem dostępu do właściwości i metod obiektu jest poprzez kropkę:
let person = {
name: 'John',
age: 30,
greet: function() {
return 'Hello!';
}
};
console.log(person.name); // Wyświetli: John
console.log(person.age); // Wyświetli: 30
console.log(person.greet()); // Wyświetli: Hello!
2. Dostęp za pomocą nawiasów klamrowych
Właściwości obiektu mogą być również dostępne za pomocą nawiasów klamrowych. Ten sposób jest przydatny, gdy nazwa właściwości jest przechowywana w zmiennej lub zawiera spacje lub specjalne znaki:
let person = {
'first name': 'John',
age: 30,
greet: function() {
return 'Hello!';
}
};
console.log(person['first name']); // Wyświetli: John
console.log(person['age']); // Wyświetli: 30
let propertyName = 'greet';
console.log(person[propertyName]()); // Wyświetli: Hello!
3. Zmiana i dodawanie właściwości
Właściwości obiektu mogą być zmieniane lub dodawane w dowolnym momencie:
let person = {
name: 'John',
age: 30
};
// Zmiana istniejącej właściwości
person.age = 31;
console.log(person.age); // Wyświetli: 31
// Dodawanie nowej właściwości
person.isStudent = false;
console.log(person.isStudent); // Wyświetli: false
4. Usuwanie właściwości
Właściwości obiektu mogą być usuwane za pomocą operatora delete:
let person = {
name: 'John',
age: 30,
isStudent: false
};
delete person.isStudent;
console.log(person.isStudent); // Wyświetli: undefined
6.3 Iteracja po właściwościach obiektu
1. Pętla for...in
Pętla for...in pozwala na przeglądanie wszystkich enumeratywnych właściwości obiektu:
let person = {
name: 'John',
age: 30,
isStudent: false
};
for (let key in person) {
console.log(`${key}: ${person[key]}`);
}
// Wyświetli:
// name: John
// age: 30
// isStudent: false
2. Metoda Object.keys()
Metoda Object.keys() zwraca tablicę wszystkich enumeratywnych właściwości obiektu:
let person = {
name: 'John',
age: 30,
isStudent: false
};
let keys = Object.keys(person);
console.log(keys); // Wyświetli: ['name', 'age', 'isStudent']
3. Metoda Object.values()
Metoda Object.values() zwraca tablicę wartości wszystkich enumeratywnych właściwości obiektu:
let person = {
name: 'John',
age: 30,
isStudent: false
};
let values = Object.values(person);
console.log(values); // Wyświetli: ['John', 30, false]
4. Metoda Object.entries()
Metoda Object.entries() zwraca tablicę par [klucz, wartość] dla wszystkich enumeratywnych właściwości obiektu:
let person = {
name: 'John',
age: 30,
isStudent: false
};
let entries = Object.entries(person);
console.log(entries); // Wyświetli: [['name', 'John'], ['age', 30], ['isStudent', false]]
6.4 Sprawdzanie obecności właściwości
1. Operator in
Operator in pozwala sprawdzić obecność właściwości w obiekcie:
let person = {
name: 'John',
age: 30
};
console.log('name' in person); // Wyświetli: true
console.log('isStudent' in person); // Wyświetli: false
2. Metoda hasOwnProperty()
Metoda hasOwnProperty() sprawdza, czy obiekt posiada określoną właściwość jako swoją własną (nie dziedziczoną):
let person = {
name: 'John',
age: 30
};
console.log(person.hasOwnProperty('name')); // Wyświetli: true
console.log(person.hasOwnProperty('isStudent')); // Wyświetli: false
GO TO FULL VERSION