Prototype-Kette und Grundlagen eigener Eigenschaften
Grundlagen der Prototype-Kette; eigene und geerbte Eigenschaften unterscheiden; Object.create verwenden; einfache Deskriptoren festlegen
Prototype-Kette und Grundlagen eigener Eigenschaften ist eine kostenlose JavaScript Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 2. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des JavaScript Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der JavaScript Academy-Kurs umfasst insgesamt 2 Lektionen.
Einführung in Prototypen
Ziel: Sehen Sie, wie Objekte über die prototype chain erben und wie Sie eigene von geerbten Schlüsseln unterscheiden.
- Prototype chain
- hasOwn vs in
- Object.create
- Grundlegende Deskriptoren
Prototype-Lookup
Wenn ein Schlüssel im Objekt nicht gefunden wird, sucht JavaScript in seinem prototype (z. B. Object.prototype).
// A simple object
const user = { name: "Ayla" };
// The prototype is another object used for fallback lookups
const proto = Object.getPrototypeOf(user);
console.log("name:", user.name);
console.log("has toString?", typeof user.toString === "function");
console.log("proto same as Object.prototype?", proto === Object.prototype);
Eigene oder geerbte Schlüssel
Object.hasOwn(obj, key) gibt nur für eigene Schlüssel true zurück. "key" in obj schließt auch geerbte Schlüssel ein.
// Own vs inherited checks
const point = { x: 1 };
// "in" sees own or inherited
console.log("x in point:", "x" in point);
console.log("toString in point:", "toString" in point);
// Only own keys
console.log("hasOwn x:", Object.hasOwn(point, "x"));
console.log("hasOwn toString:", Object.hasOwn(point, "toString"));
Grundlagen von Object.create
Object.create(proto) erstellt ein Objekt, das von proto erbt.
// Use Object.create to set a prototype
const animal = { kind: "animal" };
// pet inherits from animal
const pet = Object.create(animal);
pet.name = "Milo";
console.log("pet name:", pet.name);
console.log("pet kind (inherited):", pet.kind);
console.log("hasOwn kind?", Object.hasOwn(pet, "kind"));
Deskriptoren (kurz erklärt)
Mit Object.defineProperty können Sie für einen Schlüssel Flags wie writable und enumerable festlegen.
// Define simple descriptors
const prefs = {};
Object.defineProperty(prefs, "theme", {
value: "dark",
writable: false,
enumerable: true
});
// Try to change (silently fails in non-strict)
prefs.theme = "light";
console.log("theme:", prefs.theme);
// List keys: theme is enumerable
console.log("keys:", Object.keys(prefs));
Tipps und Checkliste
Tipps:
- Verwenden Sie Object.hasOwn(obj, key), um eigene Schlüssel zu prüfen.
- Bevorzugen Sie Object.create(proto), um kleine Prototypen zu erstellen.
- Halten Sie die Verwendung von Deskriptoren anfangs auf ein Minimum beschränkt; die Standardwerte sind ausreichend.
Quiz zu eigenen und geerbten Schlüsseln
Schnelltest: Prüfung eigener Eigenschaften.
Zusammenfassung
Zusammenfassung: Die Engine sucht fehlende Schlüssel im prototype. Verwenden Sie hasOwn ausschließlich für eigene Schlüssel, Object.create zum Festlegen eines Prototyps und Deskriptoren zum Steuern grundlegender Flags.
Häufig gestellte Fragen
Ist die Lektion „Prototype-Kette und Grundlagen eigener Eigenschaften“ kostenlos?
Ja — der vollständige Text von „Prototype-Kette und Grundlagen eigener Eigenschaften“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des JavaScript Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der JavaScript Academy-Kurs umfasst insgesamt 2 Lektionen.
Was lerne ich in „Prototype-Kette und Grundlagen eigener Eigenschaften“?
Grundlagen der Prototype-Kette; eigene und geerbte Eigenschaften unterscheiden; Object.create verwenden; einfache Deskriptoren festlegen Du übst JavaScript Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um JavaScript Academy zu starten?
Keine Vorkenntnisse erforderlich. JavaScript Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 2.
Wie lange dauert die Lektion „Prototype-Kette und Grundlagen eigener Eigenschaften“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser JavaScript Academy-Lektion Code schreiben und ausführen?
Ja. Jede JavaScript Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Prototype-Kette und Grundlagen eigener Eigenschaften
- Klassensyntax (Vorschau): constructor, Methoden, static, extends