String

const s = 'Hallo';
typeof s;          // 'string'
s.length;          // 5

// Immutability
s[0] = 'X';        // sloppy: still ignoriert; strict: TypeError
console.log(s);    // 'Hallo' — unverändert

// jede Methode gibt neuen String zurück
const upper = s.toUpperCase();
console.log(s, upper);  // 'Hallo' 'HALLO' — Original intakt

const a = 'single';
const b = "double";
const c = `template`;

// Template-Features
const name = 'Welt';
const greet = `Hallo, ${name}!`;        // Interpolation

const multi = `Zeile 1
Zeile 2
Zeile 3`;                                       // Mehrzeilig, kein \n nötig

// Escape-Regeln pro Stil
const sing = 'It\'s';                   // Single in Single
const doub = "say \"hi\"";              // Double in Double
const tick = `und \`code\``;            // Backtick in Backtick

// BMP-Zeichen: 1 Code-Unit
'a'.length;        // 1
'ä'.length;        // 1
'€'.length;        // 1   (U+20AC)

// Supplementary Plane: 2 Code-Units (Surrogate Pair)
'😀'.length;       // 2   (U+1F600)
'𝕏'.length;       // 2   (U+1D54F, mathematischer Großbuchstabe X)
'🇩🇪'.length;       // 4   (Flag = 2 Regional-Indikatoren je 2 Code-Units)

// echte Codepoint-Anzahl
[...'😀'].length;  // 1
[...'🇩🇪'].length;  // 2 — 2 Codepoints, aber 1 Grapheme

'hi'.length;        // 2  — wie erwartet
'😀'.length;        // 2  — Surrogate Pair
'👨‍👩‍👧'.length;        // 8  — ZWJ-Sequenz: 3 Personen + 2 ZWJ-Joiner
'🇩🇪'.length;        // 4  — Flag = 2 Regional Indicator Symbols

// korrekte Codepoint-Anzahl
[...'😀'].length;        // 1
[...'👨‍👩‍👧'].length;        // 5  — Personen + ZWJ als einzelne Codepoints

// visuelle Grapheme (Intl.Segmenter, ES2022)
const seg = new Intl.Segmenter('de', { granularity: 'grapheme' });
[...seg.segment('👨‍👩‍👧')].length;  // 1 — ein Grapheme
[...seg.segment('🇩🇪')].length;     // 1 — ein Grapheme

const s = 'A😀B';

// Bracket / charAt: gibt Code-Unit als String zurück
s[0];                  // 'A'
s.charAt(0);           // 'A'
s[1];                  // '\uD83D' — halbes Surrogate!
s.charAt(1);           // '\uD83D'

// charCodeAt: numerischer Wert der Code-Unit
s.charCodeAt(0);       // 65    (U+0041)
s.charCodeAt(1);       // 55357 (high surrogate)

// codePointAt: gibt echten Codepoint, auch über Surrogate-Grenze
s.codePointAt(0);      // 65       — 'A'
s.codePointAt(1);      // 128512   — 0x1F600 = 😀
s.codePointAt(2);      // 56832    — low surrogate als Fallback

// String.fromCodePoint kehrt um
String.fromCodePoint(0x1F600);  // '😀'

const s = 'A😀B';

// klassische for-i Schleife: Code-Units (kann Surrogates zerschneiden)
for (let i = 0; i < s.length; i++) {
    console.log(s[i]);  // 'A', '\uD83D', '\uDE00', 'B'
}

// for-of: korrekte Codepoint-Iteration
for (const ch of s) {
    console.log(ch);    // 'A', '😀', 'B'
}

// Spread / Array.from: ebenfalls codepoint-basiert
[...s];                 // ['A', '😀', 'B']
Array.from(s);          // ['A', '😀', 'B']

// Achtung: nur Codepoints, nicht Grapheme!
[...'👨‍👩‍👧'];               // 5 Einträge — ZWJ-Joiner als eigene Codepoints

const name = 'Anna';
const age  = 28;

// 1) Plus-Operator — laut, viele Quotes
const a = 'Hi ' + name + ', du bist ' + age + ' Jahre alt.';

// 2) Template Literal — modern, lesbar
const b = `Hi ${name}, du bist ${age} Jahre alt.`;

// 3) Array.join — sinnvoll bei vielen Stücken in Schleife
const teile = [];
for (let i = 0; i < 100; i++) teile.push(`Item ${i}`);
const c = teile.join('\n');

// Performance: alle drei sind in modernen Engines gleich schnell
// Lesbarkeit: Template gewinnt fast immer

const u = 'ä';        // 'ä' — alt, max U+FFFF
const c = '\u{1F600}';     // '😀' — Curly-Form für > U+FFFF
const t = '\u{1F1E9}\u{1F1EA}';  // '🇩🇪' — zwei Codepoints

// Curly-Form ist nicht nur kürzer, sie ist nötig für > U+FFFF.
// Ohne Curly muss man das Surrogate Pair selbst schreiben:
const alt = '😀';     // '😀' — high + low surrogate

const prim = 'hi';
const obj  = new String('hi');

typeof prim;        // 'string'
typeof obj;         // 'object'  (!)

prim === 'hi';      // true
obj === 'hi';       // false   — anderer Typ
obj == 'hi';        // true    — loose equality coerced

// alle Objekte sind truthy — auch new Boolean(false) und new String('')
Boolean(new String(''));  // true (!)

// JSON-Verhalten
JSON.stringify(prim);     // '"hi"'
JSON.stringify(obj);      // '"hi"'  — sieht gleich aus, ist aber Object

// gute Nachricht: niemand nutzt new String() ernsthaft
// String('x') OHNE new ist anders: explizite Coercion zu Primitive
String(42);         // '42' — Primitive, gut
new String(42);     // String-Object — schlecht