String vs string in TypeScript: Performance-Unterschied und Wahl

String vs string: Der stille Performance-Killer in Ihrem Code

Haben Sie sich jemals gefragt, warum TypeScript an einer Stelle String bemängelt und an einer anderen string? Oder haben Sie gesehen, wie erfahrene Entwickler das Gesicht verziehen, wenn sie new String("hallo") sehen? Diese Frage ist ein echter Dauerbrenner auf Stack Overflow mit tausenden von Aufrufen. Und das zu Recht. Der Unterschied zwischen String und string ist keine bloße Marotte der Sprache, sondern ein fundamentaler Unterschied, der Performance, Sicherheit und Lesbarkeit Ihres Codes beeinflusst.

In diesem Artikel geben wir nicht nur eine trockene Definition. Wir analysieren, was hinter jedem dieser Typen steckt, wie sie sich zur Laufzeit verhalten und warum die richtige Wahl Ihre Anwendung um dutzende Prozent beschleunigen kann. Machen Sie sich bereit, es wird spannend!

Primitive vs. Objekte: Die Grundlagen

Um den Unterschied zu verstehen, müssen wir uns daran erinnern, wie JavaScript (und damit auch TypeScript) mit Daten arbeitet. Die Sprache kennt zwei Arten von Werten:

\n
• Primitive Typen: string, number, boolean, null, undefined, symbol, bigint. Sie sind unveränderlich und werden als Wert gespeichert.
\n
• Objekte: Object, Array, Function, sowie String (großgeschrieben), Number, Boolean. Sie sind veränderlich und werden als Referenz gespeichert.
\n

Wenn Sie let name: string = "Alice" schreiben, erstellen Sie einen primitiven Wert. Wenn Sie let name: String = new String("Alice") schreiben, erstellen Sie ein Objekt-Wrapper. Und hier wird es interessant.

Der Typ string (kleingeschrieben)

Dies ist ein primitiver Typ. Er wird in 99,9% der Fälle verwendet. Er ist leichtgewichtig, schnell und vorhersagbar. Der Vergleich zweier primitiver Werte erfolgt nach ihrem Wert:

let a: string = "hallo";\nlet b: string = "hallo";\nconsole.log(a === b); // true

TypeScript empfiehlt, genau diesen Typ zu verwenden. Es ist der De-facto-Standard für die Deklaration von String-Variablen, Funktionsparametern und Rückgabewerten.

Der Typ String (großgeschrieben)

Dies ist ein Objekt-Typ, ein Konstruktor-Wrapper. Er existiert seit den Anfängen von JavaScript für die Arbeit mit String-Methoden. Seine direkte Verwendung gilt jedoch eher als Anti-Pattern, es sei denn, Sie haben eine sehr spezielle Aufgabe. Der Vergleich zweier String-Objekte erfolgt nach ihrer Referenz:

let a: String = new String("hallo");\nlet b: String = new String("hallo");\nconsole.log(a === b); // false! Es sind unterschiedliche Objekte im Speicher

Dies kann zu schwer auffindbaren Fehlern führen. Stellen Sie sich vor, Sie prüfen, ob der Wert einer Zeichenkette "hallo" ist, und erhalten false, nur weil jemand new String() verwendet hat.

Performance: Warum gewinnt string?

Kommen wir nun zum spannendsten Teil – zu Zahlen und Optimierung. Schreiben wir einen einfachen Performance-Test (Sie können ihn in Ihrer Umgebung ausführen, z.B. in Node.js oder im Browser).

// Performance-Test\nconst iterations = 1_000_000;\n\nconsole.time("string (primitiv)");\nlet sum = "";\nfor (let i = 0; i < iterations; i++) {\n    sum += "a";\n}\nconsole.timeEnd("string (primitiv)");\n\nconsole.time("String (Objekt)");\nlet sumObj = new String("");\nfor (let i = 0; i < iterations; i++) {\n    sumObj += "a"; // Hier findet Auto-Boxing und Unboxing statt\n}\nconsole.timeEnd("String (Objekt)");

Das Ergebnis auf einem typischen Rechner wird drastisch unterschiedlich sein (2-5 mal schneller für den primitiven Typ). Warum? Weil:

\n
• Der primitive Typ string ist einfach eine Zeichenkette im Speicher. Operationen damit sind auf Engine-Ebene optimiert.