0Pricing
JavaScript Academy · Lektion

Primitive Werte vs. Objekte und grundlegende Typen

Primitive Werte vs. Objekte, die sieben primitiven Datentypen, schnelle typeof-Prüfungen und häufige Fallstricke für Einsteiger.

Primitive Werte vs. Objekte und grundlegende Typen ist eine kostenlose JavaScript Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 3. 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 3 Lektionen.

Einführung

Ziel: Unterscheiden Sie Primitive von Objekten und erkennen Sie alle sieben primitiven Datentypen anhand kurzer Checks.

  • Sieben Primitive
  • Objekte und Wrapper
  • typeof im Überblick
Primitive Werte vs. Objekte und grundlegende Typen — Illustration 1

Sieben Primitive: typeof im Überblick

JavaScript hat 7 Primitive: number, bigint, string, boolean, null, undefined und symbol.

// Seven primitives and typeof
const n = 42;                 
// number
const bi = 42n;               
// bigint
const s = "hello";            
// string
const b = true;               
// boolean
const u = undefined;          
// undefined
const nl = null;              
// null (primitive)
const sy = Symbol("id");      
// symbol (unique each time)

console.log(typeof n, typeof bi, typeof s, typeof b);
console.log(typeof u, typeof nl, typeof sy);
// Note: typeof null is "object" (historical quirk)
Primitive Werte vs. Objekte und grundlegende Typen — Illustration 2

Primitive und Objekte

Primitive sind einzelne unveränderliche Werte. Objekte enthalten Eigenschaften und werden anhand ihrer Referenz verglichen (Arrays, Funktionen und Datumswerte sind Objekte).

  • Primitive werden anhand ihres Werts verglichen.
  • Objekte können erweitert und verändert werden.
Primitive Werte vs. Objekte und grundlegende Typen — Illustration 3

Fallstrick bei Wrapper-Objekten

Bevorzugen Sie Literale (z. B. "hello") gegenüber Wrappern (new String, new Number, new Boolean).

// Avoid wrapper constructors for primitives
const s1 = "hi";              
// primitive string
const s2 = new String("hi");  
// String object (wrapper)

console.log(typeof s1);       
// "string"
console.log(typeof s2);       
// "object"

console.log(s1 === "hi");     
// true (value compare)
console.log(s2 === "hi");     
// false (object vs primitive)
Primitive Werte vs. Objekte und grundlegende Typen — Illustration 4

Grundlagen von BigInt und Symbol

BigInt verarbeitet sehr große Ganzzahlen; Symbol erstellt eindeutige Schlüssel für Objekte.

// BigInt: integers beyond Number.MAX_SAFE_INTEGER
const big = 9007199254740993n;  
// 2^53 + 1
console.log(big + 7n);

// Symbol: unique identifiers
const a = Symbol("token");
const b = Symbol("token");
console.log(a === b); 
// false — symbols are always unique
Primitive Werte vs. Objekte und grundlegende Typen — Illustration 5

null und undefined

undefined: deklariert, aber kein Wert zugewiesen. null: ein ausdrücklich gesetzter „kein Wert“. Tipp: typeof null gibt "object" zurück (eine Besonderheit), aber null ist weiterhin ein primitives Datum.

Primitive Werte vs. Objekte und grundlegende Typen — Illustration 6

Quiz zu typeof null

Kurzer Check: typeof null?

Primitive Werte vs. Objekte und grundlegende Typen — Illustration 7

Zusammenfassung

Zusammenfassung: Sie haben die sieben Primitive identifiziert, sie mit Objekten verglichen, Fallstricke bei Wrappern vermieden und die Besonderheit von typeof null kennengelernt.

Primitive Werte vs. Objekte und grundlegende Typen — Illustration 8

Häufig gestellte Fragen

Ist die Lektion „Primitive Werte vs. Objekte und grundlegende Typen“ kostenlos?

Ja — der vollständige Text von „Primitive Werte vs. Objekte und grundlegende Typen“ 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 3 Lektionen.

Was lerne ich in „Primitive Werte vs. Objekte und grundlegende Typen“?

Primitive Werte vs. Objekte, die sieben primitiven Datentypen, schnelle typeof-Prüfungen und häufige Fallstricke für Einsteiger. 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 3.

Wie lange dauert die Lektion „Primitive Werte vs. Objekte und grundlegende Typen“?

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

  1. Primitive Werte vs. Objekte und grundlegende Typen
  2. typeof, Truthy/Falsy und == vs. ===
  3. Typkonvertierung: Sichere Muster zur Vermeidung von Überraschungen
← Zurück zu JavaScript Academy