1.3: TypeScript Compiler beobachten

🎯 Ziel

Du bekommst ein kleines Zahlenratespiel in TypeScript. Deine Aufgabe ist es, das Spiel auszuführen und fünf Dinge zu beobachten, die der TypeScript-Compiler beim Übersetzen in JavaScript verändert oder beachtet.

📁 Schritte

Kopiere den folgenden Quellcode in eine Datei namens zahlenraten.ts.
Kompiliere die Datei mit dem TypeScript-Compiler:
Terminal window
```
tsc zahlenraten.ts
```
Führe die Datei mit Node.js aus:
Terminal window
```
node zahlenraten.js
```
Beantworte die Beobachtungsfragen.

👀 Beobachtungsaufgabe

Beim Vergleich von zahlenraten.ts und zahlenraten.js, beantworte:

Wie kann folgender und weitere solcher Fehler behoben werden?

Cannot find name 'process'. Do you need to install type definitions for node? Try `npm i --save-dev @types/node`.ts(2580)

Was passiert mit den TypeScript-Typen wie number, string, oder eigenen Typen wie GameConfig?
Wird async/await verändert oder bleibt es gleich im JavaScript-Code?
Wie sieht eine TypeScript-Klasse in JavaScript aus?
Was passiert mit private-Eigenschaften der Klasse? Sind sie wirklich privat im JavaScript-Code?
Wird import * as readline from "node:readline"; direkt so übernommen oder umgewandelt?

💡 Tipp: Öffne beide Dateien (.ts und .js) nebeneinander im Editor und vergleiche sie Zeile für Zeile!

🧾 TypeScript-Quellcode (zahlenraten.ts)

import * as readline from "node:readline";

type GameConfig = {
  min: number;
  max: number;
  maxTries: number;
};

class NumberGuessingGame {
  private readonly config: GameConfig;
  private secretNumber: number;
  private attemptsLeft: number;
  private rl: readline.Interface;

  constructor(config: GameConfig) {
    this.config = config;
    this.secretNumber = this.generateSecretNumber();
    this.attemptsLeft = config.maxTries;
    this.rl = readline.createInterface({
      input: process.stdin,
      output: process.stdout,
    });
  }

  private generateSecretNumber(): number {
    const { min, max } = this.config;
    return Math.floor(Math.random() * (max - min + 1)) + min;
  }

  private askQuestion(query: string): Promise<string> {
    return new Promise((resolve) => {
      this.rl.question(query, resolve);
    });
  }

  private async getGuess(): Promise<number | null> {
    const input = await this.askQuestion(
      `Rate eine Zahl zwischen ${this.config.min} und ${this.config.max}: `
    );
    const parsed = parseInt(input, 10);
    if (isNaN(parsed)) return null;
    return parsed;
  }

  private checkGuess(guess: number): "correct" | "low" | "high" {
    if (guess === this.secretNumber) return "correct";
    return guess < this.secretNumber ? "low" : "high";
  }

  public async start(): Promise<void> {
    console.log("🧠 Zahlenratespiel gestartet!");

    while (this.attemptsLeft > 0) {
      const guess = await this.getGuess();
      if (guess === null) {
        console.log("⚠️ Ungültige Eingabe. Bitte gib eine Zahl ein.");
        continue;
      }

      this.attemptsLeft--;

      const result = this.checkGuess(guess);

      if (result === "correct") {
        console.log(`🎉 Richtig! Die Zahl war ${this.secretNumber}.`);
        this.rl.close();
        return;
      } else {
        console.log(
          result === "low" ? "🔻 Zu niedrig!" : "🔺 Zu hoch!",
          `(${this.attemptsLeft} Versuche übrig)`
        );
      }
    }

    console.log(`❌ Leider verloren. Die Zahl war ${this.secretNumber}.`);
    this.rl.close();
  }
}

const config: GameConfig = {
  min: 1,
  max: 100,
  maxTries: 7,
};

const game = new NumberGuessingGame(config);
game.start();