Obiekty

Frontend SELF PL
Poziom 36, Lekcja 0
Dostępny

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.

JavaScript
    
      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:

JavaScript
    
      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:

JavaScript
    
      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:

JavaScript
    
      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ć:

JavaScript
    
      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ści
  • writable — czy wartość można zmieniać (domyślnie false)
  • enumerable — czy właściwość pojawia się w for...in i Object.keys() (domyślnie false)
  • configurable — czy właściwość można usunąć lub zmienić jej ustawienia (domyślnie false)
  • get / set — getter i setter zamiast zwykłej wartości. Getter uruchamia się przy odczycie, setter przy zapisie

Wszystko razem:

JavaScript
    
      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ę:

JavaScript
    
      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:

JavaScript
    
      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:

JavaScript
    
      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:

JavaScript
    
      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:

JavaScript
    
      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:

JavaScript
    
      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:

JavaScript
    
      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:

JavaScript
    
      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:

JavaScript
    
      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ą):

JavaScript
    
      let person = {
        name: 'John',
        age: 30
      };

      console.log(person.hasOwnProperty('name')); // Wyświetli: true
      console.log(person.hasOwnProperty('isStudent')); // Wyświetli: false
    
  
1
Zadanie
Frontend SELF PL, poziom 36, lekcja 0
Niedostępne
Właściwości obiektu
Właściwości obiektu
1
Zadanie
Frontend SELF PL, poziom 36, lekcja 0
Niedostępne
Zmiana właściwości
Zmiana właściwości
Komentarze
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION