TypeScript Academy · Lektion

ReadonlyArray und ReadonlyMap

Verwenden Sie integrierte readonly-Sammlungstypen.

ReadonlyArray und ReadonlyMap ist eine kostenlose TypeScript Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. 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 TypeScript Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der TypeScript Academy-Kurs umfasst insgesamt 4 Lektionen.

Schreibgeschützte Sammlungstypen

Neben Arrays bietet TypeScript schreibgeschützte Varianten seiner integrierten Sammlungen: ReadonlyArray<T>, ReadonlyMap<K, V> und ReadonlySet<T>. Jede davon stellt nur die nicht verändernden Teile ihrer API bereit.

const arr: ReadonlyArray<number> = [1, 2, 3];
console.log(arr.length, arr.includes(2));

Zusammenfassung zu ReadonlyArray

ReadonlyArray<T> erlaubt Iteration, Indexzugriff und Methoden wie map und filter, aber nicht push, pop oder die Zuweisung an einen Index. Es ist die Array-Variante der Readonly-Familie.

const tags: ReadonlyArray<string> = ['ts', 'js'];
console.log(tags.map((t) => t.toUpperCase()));
// tags.push('css'); // Error

ReadonlyMap

ReadonlyMap<K, V> ermöglicht das Nachschlagen, Iterieren und Prüfen von Schlüsseln, entfernt aber set, delete und clear. Aus Sicht des Nutzers ist der Inhalt der Map unveränderlich.

const ages: ReadonlyMap<string, number> = new Map([['Ada', 30], ['Sam', 25]]);
console.log(ages.get('Ada'), ages.has('Sam'));
// ages.set('Lee', 40); // Error

Aus einer ReadonlyMap lesen

Alle Leseoperationen bleiben erhalten: get, has, size, keys, values, entries und die Iteration. Nur die verändernden Methoden entfallen.

const m: ReadonlyMap<string, number> = new Map([['a', 1], ['b', 2]]);
for (const [k, v] of m) {
  console.log(k, v);
}
console.log('size:', m.size);

ReadonlySet

ReadonlySet<T> unterstützt die Prüfung der Zugehörigkeit und die Iteration, entfernt aber add, delete und clear. Verwenden Sie es für feste Mengen zulässiger Werte.

const allowed: ReadonlySet<string> = new Set(['read', 'write']);
console.log(allowed.has('read'), allowed.has('delete'));
// allowed.add('admin'); // Error

Über ein ReadonlySet iterieren

Sie können über ein ReadonlySet iterieren und seine size lesen, aber seinen Inhalt nicht ändern. Dadurch eignet es sich ideal für Whitelists und Berechtigungsmengen.

const perms: ReadonlySet<string> = new Set(['view', 'edit']);
perms.forEach((p) => console.log('perm:', p));
console.log('count:', perms.size);

Readonly an Funktionen übergeben

Akzeptieren Sie in Funktionen, die nur lesen sollen, einen schreibgeschützten Sammlungstyp. Das vermittelt die Absicht und verhindert, dass die Funktion Daten verändert, die dem Aufrufer gehören.

function describe(set: ReadonlySet<string>): string {
  return 'has ' + set.size + ' items';
}
const s = new Set(['x', 'y']);
console.log(describe(s));

Veränderliche Sammlungen sind zuweisbar

Eine reguläre Map oder ein reguläres Set kann seinem schreibgeschützten Gegenstück zugewiesen werden, weil Sie die Fähigkeiten einschränken und nicht erweitern. Die Funktion gibt lediglich ihre Änderungsrechte auf.

function keys(m: ReadonlyMap<string, number>): string[] {
  return Array.from(m.keys());
}
const real = new Map([['a', 1]]);
console.log(keys(real));

APIs für unveränderliche Sammlungen

Schreibgeschützte Sammlungstypen beschreiben eine unveränderliche Ansicht. Das zugrunde liegende Objekt kann an anderer Stelle weiterhin veränderlich sein; der Readonly-Typ schränkt nur ein, was diese Referenz tun kann.

const backing = new Set<number>([1, 2]);
const view: ReadonlySet<number> = backing;
// view.add(3); // Error through the readonly view
backing.add(3); // but the original can still mutate
console.log(view.size);

Den passenden Readonly-Typ wählen

Wählen Sie den Readonly-Typ passend zu Ihrer Datenstruktur: ReadonlyArray für geordnete Listen, ReadonlyMap für Schlüssel-Wert-Zuordnungen und ReadonlySet für eindeutige Zugehörigkeit. Jeder Typ erzwingt Unveränderlichkeit für seine jeweilige Struktur.

const roles: ReadonlySet<string> = new Set(['admin', 'user']);
const limits: ReadonlyMap<string, number> = new Map([['admin', 100]]);
console.log(roles.has('user'), limits.get('admin'));

Sicherer gemeinsam genutzter Zustand

Wenn Sie interne Sammlungen als schreibgeschützte Typen nach außen geben, verhindern Sie, dass Aufrufer den Zustand Ihres Moduls beschädigen. Sie können die Daten frei untersuchen, aber nur Ihr Code kann sie ändern.

class Registry {
  private items = new Set<string>();
  add(name: string): void { this.items.add(name); }
  get all(): ReadonlySet<string> { return this.items; }
}
const r = new Registry();
r.add('a');
console.log(r.all.has('a'));

Kurzer Check

Testen Sie Ihr Verständnis der schreibgeschützten Sammlungstypen.

Zusammenfassung: Schreibgeschützte Sammlungen

Sie haben die Familie der schreibgeschützten Sammlungen kennengelernt:

ReadonlyArray<T>, ReadonlyMap<K, V> und ReadonlySet<T> stellen nur Leseoperationen bereit.
Verändernde Methoden (set, add, delete, push) entfallen.
Veränderliche Sammlungen können ihren schreibgeschützten Gegenstücken zugewiesen werden.
Sie eignen sich hervorragend als Parameter- und Rückgabetypen für einen sichereren gemeinsam genutzten Zustand.

Zum Abschluss folgen Muster für tiefe Unveränderlichkeit.

function count(s: ReadonlySet<number>): number {
  return s.size;
}
console.log(count(new Set([1, 2, 3])));

Häufig gestellte Fragen

Ist die Lektion „ReadonlyArray und ReadonlyMap“ kostenlos?

Ja — der vollständige Text von „ReadonlyArray und ReadonlyMap“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des TypeScript Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der TypeScript Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „ReadonlyArray und ReadonlyMap“?

Verwenden Sie integrierte readonly-Sammlungstypen. Du übst TypeScript 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 TypeScript Academy zu starten?

Keine Vorkenntnisse erforderlich. TypeScript 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 3 von 4.

Wie lange dauert die Lektion „ReadonlyArray und ReadonlyMap“?

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 TypeScript Academy-Lektion Code schreiben und ausführen?

Ja. Jede TypeScript 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

← Zurück zu TypeScript Academy