collection

src/03-klassen/KATA/solution.ts

@@ -0,0 +1,77 @@
+// 1. Basisklasse `Person`
+class Person {
+  constructor(public name: string, public age: number) {}
+
+  getInfo(): string {
+    return `Name: ${this.name}, Alter: ${this.age}`;
+  }
+}
+
+// 2. Abgeleitete Klasse `Employee`
+class Employee extends Person {
+  constructor(
+    name: string,
+    age: number,
+    public position: string,
+    public email: string,
+    public phone: string
+  ) {
+    super(name, age);
+  }
+
+  override getInfo(): string {
+    return `${super.getInfo()}, Position: ${this.position}`;
+  }
+
+  getContactInfo(): string {
+    return `Email: ${this.email}, Phone: ${this.phone}`;
+  }
+}
+
+// 3. Interface `IContact`
+interface IContact {
+  email: string;
+  phone: string;
+  getContactInfo(): string;
+}
+
+// 4. `Employee` implementiert `IContact`
+class EmployeeWithContact extends Employee implements IContact {}
+
+// 5. Type Alias für EmployeeRecord
+type EmployeeRecord = {
+  id: number;
+  data: Employee;
+};
+
+// 6. Klasse `Company` mit Index-Signatur
+class Company {
+  // protected employees: { [id: number]: Employee } = {};
+  protected employees: EmployeeRegistry = {};
+
+  addEmployee(employee: Employee): void {
+    const id = Object.keys(this.employees).length + 1;
+    this.employees[id] = employee;
+  }
+
+  getEmployee(id: number): Employee | undefined {
+    return this.employees[id];
+  }
+}
+
+// Bonus: `removeEmployee()` implementieren
+class ExtendedCompany extends Company {
+  removeEmployee(id: number): void {
+    delete this.employees[id];
+  }
+}
+
+// Alternative mit `Record<number, Employee>`
+type EmployeeRegistry = Record<number, Employee>;
+
+const c = new ExtendedCompany();
+c.addEmployee(new Employee('Alice', 28, 'admin', 'alice@mail.com', '555'));
+c.addEmployee(new Employee('Bob', 42, 'admin', 'bob@mail.com', '666'));
+
+console.log(c.getEmployee(1));
+c.removeEmployee(1);

src/03-klassen/aliases.ts

@@ -0,0 +1,39 @@
+type UserID = string | number;
+
+let user1: UserID = 123;
+let user2: UserID = 'abc123';
+
+// Interface nur für Objekte
+interface Person {
+  name: string;
+}
+
+// Type kann Union Types enthalten
+type Direction = 'north' | 'south' | 'east' | 'west';
+type Status = 'active' | 'inactive' | 'banned';
+
+let status: Status = 'active';
+let direction: Direction = 'west';
+
+// Union Types
+type Result<T> = {
+  data: T;
+  error: string | null;
+};
+
+// Funktion-Types
+type CallbackFn = (error: Error | null, data: any) => void;
+
+// Literal Types
+type AddFunction = (a: number, b: number) => number;
+
+const add: AddFunction = (x, y) => x + y;
+console.log(add(3, 5)); // 8
+
+type UserRoles = Record<string, 'admin' | 'user' | 'guest'>;
+
+const roles: UserRoles = {
+  alice: 'admin',
+  bob: 'user',
+  charlie: 'guest',
+};

src/03-klassen/index-signatures.ts

@@ -0,0 +1,51 @@
+// 1. Index-Signatur für allgemeine Einstellungen
+interface UserSettings {
+  [key: string]: string;
+}
+
+const settings: UserSettings = {
+  theme: 'dark',
+  language: 'en',
+  fontSize: '14px',
+};
+
+// 2. Einschränkung der erlaubten Werte
+interface ThemeSettings {
+  [key: string]: 'light' | 'dark' | 'auto';
+}
+
+const themeConfig: ThemeSettings = {
+  theme: 'dark',
+  mode: 'auto',
+  // color: "blue", // Fehler, nicht erlaubt
+};
+
+// 3. Mehrere Typen als Werte
+interface UserPreferences {
+  [key: string]: string | number | boolean;
+}
+
+const preferences: UserPreferences = {
+  theme: 'light',
+  notifications: true,
+  volume: 75,
+};
+
+// 4. Kombination mit festen Eigenschaften
+interface UserProfile {
+  username: string;
+  email: string;
+  [key: string]: string;
+}
+
+const user: UserProfile = {
+  username: 'johndoe',
+  email: 'johndoe@example.com',
+  country: 'Germany', // Erlaubt durch die Index-Signatur
+};
+
+// 5. Alternativen zu Index-Signaturen
+const themeConfigAlt: Record<string, 'light' | 'dark' | 'auto'> = {
+  theme: 'dark',
+  mode: 'light',
+};

src/04-collections/KATA/starter.ts

@@ -0,0 +1,72 @@
+// 1. Arrays: Implementiere die folgenden Funktionen
+export function squareNumbers(numbers) {
+  // TODO: Jedes Element quadrieren und zurückgeben
+  return [];
+}
+
+export function filterEvenNumbers(numbers) {
+  // TODO: Nur gerade Zahlen zurückgeben
+  return [];
+}
+
+export function sumNumbers(numbers) {
+  // TODO: Die Summe aller Zahlen berechnen
+  return 0;
+}
+
+export function findFirstGreaterThan(numbers, limit) {
+  // TODO: Das erste Element finden, das größer als `limit` ist
+  return undefined;
+}
+
+export function sortNumbersDescending(numbers) {
+  // TODO: Das Array in absteigender Reihenfolge sortieren
+  return [];
+}
+
+export function sliceNumbers(numbers, start, end) {
+  // TODO: Einen Teil des Arrays extrahieren
+  return [];
+}
+
+export function modifyArray(numbers, index, newValue) {
+  // TODO: Ein Element ersetzen und das Array zurückgeben
+  return [];
+}
+
+// 2. Maps: Implementiere die folgenden Funktionen
+export function createUserMap() {
+  // TODO: Eine Map mit zwei Nutzern erstellen
+  return new Map();
+}
+
+export function getUserById(users, id) {
+  // TODO: Den Nutzer mit der angegebenen ID zurückgeben
+  return undefined;
+}
+
+export function getAllUserIds(users) {
+  // TODO: Alle Schlüssel zurückgeben
+  return [];
+}
+
+export function getAllUserNames(users) {
+  // TODO: Alle Werte zurückgeben
+  return [];
+}
+
+// 3. Sets: Implementiere die folgenden Funktionen
+export function createUniqueNumberSet(numbers) {
+  // TODO: Ein Set mit eindeutigen Zahlen erstellen
+  return new Set();
+}
+
+export function isNumberInSet(set, value) {
+  // TODO: Prüfen, ob `value` im Set enthalten ist
+  return false;
+}
+
+export function convertSetToArray(set) {
+  // TODO: Set in ein Array umwandeln
+  return [];
+}

src/04-collections/KATA/tests.ts

@@ -0,0 +1,86 @@
+import { assert, assertEquals } from 'jsr:@std/assert';
+import {
+  convertSetToArray,
+  createUniqueNumberSet,
+  createUserMap,
+  filterEvenNumbers,
+  findFirstGreaterThan,
+  getAllUserIds,
+  getAllUserNames,
+  getUserById,
+  isNumberInSet,
+  modifyArray,
+  sliceNumbers,
+  sortNumbersDescending,
+  squareNumbers,
+  sumNumbers,
+} from './starter.ts';
+
+Deno.test('squareNumbers quadriert alle Zahlen', () => {
+  assertEquals(squareNumbers([1, 2, 3]), [1, 4, 9]);
+});
+
+Deno.test('filterEvenNumbers filtert nur gerade Zahlen', () => {
+  assertEquals(filterEvenNumbers([1, 2, 3, 4, 5]), [2, 4]);
+});
+
+Deno.test('sumNumbers berechnet die Summe', () => {
+  assertEquals(sumNumbers([1, 2, 3, 4, 5]), 15);
+});
+
+Deno.test(
+  'findFirstGreaterThan findet das erste Element über dem Limit',
+  () => {
+    assertEquals(findFirstGreaterThan([1, 2, 3, 4, 5], 3), 4);
+  }
+);
+
+Deno.test('sortNumbersDescending sortiert das Array absteigend', () => {
+  assertEquals(sortNumbersDescending([3, 1, 4, 2, 5]), [5, 4, 3, 2, 1]);
+});
+
+Deno.test('sliceNumbers extrahiert den gewünschten Teil des Arrays', () => {
+  assertEquals(sliceNumbers([1, 2, 3, 4, 5], 1, 3), [2, 3]);
+});
+
+Deno.test('modifyArray ersetzt das Element an einem bestimmten Index', () => {
+  assertEquals(modifyArray([1, 2, 3, 4, 5], 2, 99), [1, 2, 99, 4, 5]);
+});
+
+Deno.test('createUserMap erstellt eine Map mit Nutzern', () => {
+  const users = createUserMap();
+  assert(users.size === 2);
+});
+
+Deno.test('getUserById gibt den richtigen Nutzer zurück', () => {
+  const users = createUserMap();
+  assertEquals(getUserById(users, 1), 'Alice');
+});
+
+Deno.test('getAllUserIds gibt alle Schlüssel zurück', () => {
+  const users = createUserMap();
+  assertEquals(getAllUserIds(users), [1, 2]);
+});
+
+Deno.test('getAllUserNames gibt alle Werte zurück', () => {
+  const users = createUserMap();
+  assertEquals(getAllUserNames(users), ['Alice', 'Bob']);
+});
+
+Deno.test('createUniqueNumberSet erstellt ein Set ohne Duplikate', () => {
+  assertEquals(
+    Array.from(createUniqueNumberSet([1, 2, 2, 3, 3, 4])),
+    [1, 2, 3, 4]
+  );
+});
+
+Deno.test('isNumberInSet prüft, ob eine Zahl existiert', () => {
+  const set = new Set([1, 2, 3]);
+  assert(isNumberInSet(set, 2));
+  assert(!isNumberInSet(set, 5));
+});
+
+Deno.test('convertSetToArray wandelt ein Set in ein Array um', () => {
+  const set = new Set([1, 2, 3]);
+  assertEquals(convertSetToArray(set), [1, 2, 3]);
+});