Objekte

Frontend SELF DE
Level 36, Lektion 0
Verfügbar

6.1 Erstellen von Objekten

Objekte sind eine der Hauptdatenstrukturen in JavaScript und werden häufig zur Speicherung und Verwaltung von Daten verwendet. Ein Objekt ist eine Sammlung von Eigenschaften, wobei jede Eigenschaft aus einem Schlüssel (Name) und einem Wert besteht. In dieser Vorlesung besprechen wir die Erstellung von Objekten sowie den Zugriff auf ihre Eigenschaften und Methoden.

1. Objekt-Literal

Die häufigste Methode, ein Objekt in JavaScript zu erstellen, ist die Verwendung eines Objekt-Literals.

In diesem Beispiel haben wir ein Objekt person mit vier Eigenschaften erstellt: name, age, isStudent und greet.

JavaScript
    
      let person = {
        name: 'John',
        age: 30,
        isStudent: false,
        greet: function() {
          return 'Hello!';
        }
      };
    
  

2. Object Konstruktor

Objekte können auch mit dem Konstruktor Object() erstellt werden.

Diese Methode ist gleichwertig zur Erstellung eines Objekts mit einem Objekt-Literal, aber wortreicher:

JavaScript
    
      let person = new Object();
      person.name = 'John';
      person.age = 30;
      person.isStudent = false;
      person.greet = function() {
        return 'Hello!';
      };
    
  

3. Konstruktorfunktion

Eine Konstruktorfunktion ermöglicht es, mehrere Instanzen von Objekten mit den gleichen Eigenschaften und Methoden zu erstellen.

In diesem Beispiel wird die Konstruktorfunktion Person() verwendet, um die Objekte john und jane mit den gleichen Eigenschaften und Methoden zu erstellen:

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. Methode Object.create()

Die Methode Object.create() erstellt ein neues Objekt und weist ihm sofort einen Prototypen zu — ein anderes Objekt, in dem das neue Objekt nach Eigenschaften und Methoden sucht, die es selbst nicht besitzt.

In diesem Beispiel wird das Objekt john auf Basis des Prototyps personPrototype erstellt:

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);    // Gibt aus: John
      console.log(john.greet()); // Gibt aus: Hello!
    
  

Bemerkenswert ist die letzte Zeile. Das Objekt john hat keine eigene Methode greet — hineingeschrieben wurden nur name, age und isStudent. Trotzdem funktioniert john.greet(): Beim Zugriff auf eine Eigenschaft sucht JavaScript zuerst im Objekt selbst und steigt, wenn dort nichts gefunden wird, zum Prototypen auf. Dieser Suchweg heißt Prototypenkette.

Der Unterschied zwischen einer eigenen und einer geerbten Eigenschaft ist leicht zu sehen:

JavaScript
    
      console.log(john.hasOwnProperty('name'));  // Gibt aus: true
      console.log(john.hasOwnProperty('greet')); // Gibt aus: false
      console.log('greet' in john);              // Gibt aus: true
    
  

hasOwnProperty() beantwortet die Frage „hat das Objekt selbst diese Eigenschaft“, der Operator in dagegen „ist die Eigenschaft überhaupt erreichbar, notfalls über die Prototypenkette“. Daher die unterschiedlichen Antworten für greet.

Wichtig: Die Eigenschaften des Prototyps werden nicht kopiert. personPrototype bleibt ein eigenständiges Objekt, und john verweist lediglich darauf. Deshalb können sich Hunderte Objekte einen Prototypen teilen, und greet liegt nur einmal im Speicher. Zum Vergleich: Bei der Konstruktorfunktion aus Beispiel 3 bekam jedes erzeugte Objekt seine eigene Kopie von greet.

Das zweite Argument: Eigenschaften mit Einstellungen

Object.create() hat ein zweites, optionales Argument — ein Objekt, das die sofort anzulegenden Eigenschaften beschreibt. Sie werden nicht einfach über einen Wert definiert, sondern über einen Deskriptor — einen Satz von Einstellungen:

  • value — der Wert der Eigenschaft selbst
  • writable — ob der Wert geändert werden darf (Standard: false)
  • enumerable — ob die Eigenschaft in for...in und Object.keys() auftaucht (Standard: false)
  • configurable — ob die Eigenschaft gelöscht oder ihre Einstellungen geändert werden dürfen (Standard: false)
  • get / set — Getter und Setter statt eines gewöhnlichen Werts. Der Getter läuft beim Lesen, der Setter beim Schreiben

Alles zusammengesetzt:

JavaScript
    
      let john = Object.create(personPrototype, {
        name: {
          value: 'John',
          writable: true,        // Wert darf geändert werden
          enumerable: true       // Eigenschaft ist in for...in sichtbar
        },
        id: {
          value: 1001,
          writable: false,       // nur lesbar
          enumerable: true
        },
        info: {
          enumerable: true,
          get: function() {      // Getter: läuft beim Lesen
            return this.name + ' #' + this.id;
          },
          set: function(value) { // Setter: läuft beim Schreiben
            this.name = value;
          }
        }
      });

      console.log(john.info);  // Gibt aus: John #1001

      john.name = 'Johnny';    // funktioniert
      john.id = 2002;          // passiert stillschweigend nichts
      console.log(john.info);  // Gibt aus: Johnny #1001
    
  

Zu beachten: Alle drei Flags sind standardmäßig false, beim zweiten Argument müssen sie also fast immer explizit gesetzt werden. Eine Zuweisung an eine Eigenschaft mit writable: false schlägt im normalen Modus stillschweigend fehl und wirft im strikten Modus ('use strict') einen TypeError.

Ein weiterer nützlicher Fall ist Object.create(null). Ein solches Objekt hat überhaupt keinen Prototypen: kein toString(), kein hasOwnProperty(), keine geerbten Methoden. Das macht es zu einem praktischen „sauberen Wörterbuch“, in dem jeder Schlüssel garantiert selbst gesetzt und nicht von Object.prototype geerbt ist.

6.2 Zugriff auf Eigenschaften und Methoden

1. Zugriff mit Punkt-Notation

Die häufigste Methode, auf die Eigenschaften und Methoden eines Objekts zuzugreifen, ist die Punkt-Notation:

JavaScript
    
      let person = {
        name: 'John',
        age: 30,
        greet: function() {
          return 'Hello!';
        }
      };

      console.log(person.name);  // Gibt aus: John
      console.log(person.age);   // Gibt aus: 30
      console.log(person.greet()); // Gibt aus: Hello!
    
  

2. Zugriff mit eckigen Klammern

Auf die Eigenschaften eines Objekts kann auch mit eckigen Klammern zugegriffen werden. Diese Methode ist nützlich, wenn der Name der Eigenschaft in einer Variablen gespeichert ist oder Leerzeichen oder Sonderzeichen enthält:

JavaScript
    
      let person = {
        'first name': 'John',
        age: 30,
        greet: function() {
          return 'Hello!';
        }
      };

      console.log(person['first name']); // Gibt aus: John
      console.log(person['age']);        // Gibt aus: 30

      let propertyName = 'greet';
      console.log(person[propertyName]()); // Gibt aus: Hello!
    
  

3. Ändern und Hinzufügen von Eigenschaften

Die Eigenschaften eines Objekts können jederzeit geändert oder hinzugefügt werden:

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

      // Änderung einer vorhandenen Eigenschaft
      person.age = 31;
      console.log(person.age); // Gibt aus: 31

      // Hinzufügen einer neuen Eigenschaft
      person.isStudent = false;
      console.log(person.isStudent); // Gibt aus: false
    
  

4. Löschen von Eigenschaften

Die Eigenschaften eines Objekts können mit dem Operator delete gelöscht werden:

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

      delete person.isStudent;
      console.log(person.isStudent); // Gibt aus: undefined
    
  

6.3 Iteration über die Eigenschaften eines Objekts

1. for...in Schleife

Die for...in Schleife ermöglicht es, alle aufzählbaren Eigenschaften eines Objekts zu durchlaufen:

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

      for (let key in person) {
        console.log(`${key}: ${person[key]}`);
      }

      // Gibt aus:
      // name: John
      // age: 30
      // isStudent: false
    
  

2. Methode Object.keys()

Die Methode Object.keys() gibt ein Array mit allen aufzählbaren Eigenschaften eines Objekts zurück:

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

      let keys = Object.keys(person);
      console.log(keys); // Gibt aus: ['name', 'age', 'isStudent']
    
  

3. Methode Object.values()

Die Methode Object.values() gibt ein Array mit den Werten aller aufzählbaren Eigenschaften eines Objekts zurück:

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

      let values = Object.values(person);

      console.log(values); // Gibt aus: ['John', 30, false]
    
  

4. Methode Object.entries()

Die Methode Object.entries() gibt ein Array von Paaren [Schlüssel, Wert] für alle aufzählbaren Eigenschaften eines Objekts zurück:

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

      let entries = Object.entries(person);

      console.log(entries); // Gibt aus: [['name', 'John'], ['age', 30], ['isStudent', false]]
    
  

6.4 Überprüfung der Eigenschaften

1. Operator in

Der Operator in ermöglicht es zu überprüfen, ob eine Eigenschaft in einem Objekt vorhanden ist:

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

      console.log('name' in person); // Gibt aus: true
      console.log('isStudent' in person); // Gibt aus: false
    
  

2. Methode hasOwnProperty()

Die Methode hasOwnProperty() überprüft, ob ein Objekt eine bestimmte Eigenschaft als eigene (nicht geerbte) besitzt:

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

      console.log(person.hasOwnProperty('name')); // Gibt aus: true
      console.log(person.hasOwnProperty('isStudent')); // Gibt aus: false
    
  
1
Aufgabe
Frontend SELF DE, Level 36, Lektion 0
Gesperrt
Objekteigenschaften
Objekteigenschaften
1
Aufgabe
Frontend SELF DE, Level 36, Lektion 0
Gesperrt
Änderung von Eigenschaften
Änderung von Eigenschaften
Kommentare
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION