0Pricing
TypeScript Academy · Lektion

Ein einfaches Linting-Tool erstellen

Erstellen Sie mit der Compiler-API ein benutzerdefiniertes Diagnosewerkzeug.

Ein einfaches Linting-Tool erstellen ist eine kostenlose TypeScript Academy-Lektion auf CoddyKit. Dies ist Lektion 4 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.

Was ist ein Linting-Tool?

Ein Linting-Tool analysiert Quellcode, um Probleme mit Stil oder Korrektheit zu melden. Mit der TypeScript-Compiler-API können Sie typbewusste Regeln erstellen, die ESLint-Plugins allein nicht umsetzen können.

// Goal: warn when console.log is called in TypeScript files

Projekteinrichtung

Erstellen Sie ein Node.js-Skript, das ein TypeScript-Programm lädt, den AST durchläuft und Diagnosen meldet.

import ts from "typescript";
import path from "path";

const files = ["src/index.ts"];
const program = ts.createProgram(files, { strict: true });

Eine Regel definieren

Eine Regel ist eine Funktion, die einen AST-Knoten empfängt und bei einer Regelverletzung optional eine Diagnosemeldung zurückgibt.

type Diagnostic = { file: string; line: number; message: string };

function noConsoleLog(node: ts.Node, sf: ts.SourceFile): Diagnostic | null {
  if (!ts.isCallExpression(node)) return null;
  const expr = node.expression.getText(sf);
  if (expr !== "console.log") return null;
  const { line } = sf.getLineAndCharacterOfPosition(node.pos);
  return { file: sf.fileName, line: line + 1, message: "No console.log allowed" };
}

Den AST durchlaufen

Schreiben Sie ein rekursives Durchlaufen, das alle Regeln auf jeden Knoten in jeder Quelldatei anwendet.

function walk(
  node: ts.Node,
  sf: ts.SourceFile,
  rules: ((n: ts.Node, sf: ts.SourceFile) => Diagnostic | null)[]
): Diagnostic[] {
  const diags: Diagnostic[] = [];
  for (const rule of rules) {
    const d = rule(node, sf);
    if (d) diags.push(d);
  }
  ts.forEachChild(node, child => diags.push(...walk(child, sf, rules)));
  return diags;
}

Den Linter ausführen

Durchlaufen Sie alle Quelldateien, wenden Sie die Regeln an und geben Sie die Diagnosen aus.

const rules = [noConsoleLog];
const allDiagnostics: Diagnostic[] = [];

for (const sf of program.getSourceFiles()) {
  if (!sf.isDeclarationFile) {
    allDiagnostics.push(...walk(sf, sf, rules));
  }
}

allDiagnostics.forEach(d =>
  console.log(`${d.file}:${d.line} — ${d.message}`)
);

Eine typbewusste Regel hinzufügen

Verwenden Sie den TypeChecker, um Regeln zu erstellen, die vom TypeScript-Typ eines Ausdrucks abhängen.

const checker = program.getTypeChecker();

function noAnyReturn(node: ts.Node, sf: ts.SourceFile): Diagnostic | null {
  if (!ts.isFunctionDeclaration(node)) return null;
  const sig = checker.getSignatureFromDeclaration(node);
  if (!sig) return null;
  const ret = checker.getReturnTypeOfSignature(sig);
  if (ret.flags & ts.TypeFlags.Any) {
    const { line } = sf.getLineAndCharacterOfPosition(node.pos);
    return { file: sf.fileName, line: line + 1, message: "Function returns any" };
  }
  return null;
}

Exit-Code für CI

Geben Sie einen Exit-Code ungleich null zurück, wenn Diagnosen gefunden wurden, damit CI-Pipelines den Build fehlschlagen lassen können.

if (allDiagnostics.length > 0) {
  console.error(`${allDiagnostics.length} lint error(s)`);
  process.exit(1);
}
process.exit(0);

Regel: Keine ungenutzten Variablen

Die Compiler-API stellt über ts.getPreEmitDiagnostics Diagnosen zu ungenutzten Variablen bereit und ergänzt Ihre benutzerdefinierten Regeln um integrierte Prüfungen.

const preEmit = ts.getPreEmitDiagnostics(program);
preEmit.forEach(d => {
  const msg = ts.flattenDiagnosticMessageText(d.messageText, "
");
  console.log(msg);
});

Regel: Rückgabetypen erforderlich

Eine Regel, die warnt, wenn Funktionen keine expliziten Rückgabetyp-Annotationen besitzen, hilft dabei, eine konsequente Dokumentation sicherzustellen.

function requireReturnType(node: ts.Node, sf: ts.SourceFile): Diagnostic | null {
  if (!ts.isFunctionDeclaration(node)) return null;
  if (!node.type) {
    const { line } = sf.getLineAndCharacterOfPosition(node.pos);
    return { file: sf.fileName, line: line + 1, message: "Missing return type" };
  }
  return null;
}

Mit ESLint vergleichen

Ihr benutzerdefinierter Linter ergänzt ESLint. Verwenden Sie ESLint für Stilregeln und Ihr Tool auf Basis der TypeScript-Compiler-API für typbewusste Regeln, die ESLint nicht ausdrücken kann.

// ESLint: stylistic and common pattern rules
// Compiler API linter: deep type reasoning, custom constraints

Zusammenfassung: Einen Linter erstellen

Ein Linter auf Basis der TypeScript-Compiler-API erstellt ein Programm, durchläuft den AST mit Regeln, fragt optional den TypeChecker ab und beendet sich bei Fehlern mit einem Exit-Code ungleich null. Dieser Ansatz ermöglicht wirklich typbewusste Lint-Regeln.

Schnelltest

Was verschafft einem Linter auf Basis der Compiler-API einen Vorteil gegenüber ESLint?

Das haben Sie gelernt

Sie haben mit der Compiler-API einen einfachen TypeScript-Linter erstellt: ein Programm laden, den AST durchlaufen, Regeln anwenden (optional typbewusst) und Diagnosen melden. Dies bildet die Grundlage für benutzerdefinierte statische Analyse in jedem TypeScript-Projekt.

Häufig gestellte Fragen

Ist die Lektion „Ein einfaches Linting-Tool erstellen“ kostenlos?

Ja — der vollständige Text von „Ein einfaches Linting-Tool erstellen“ 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 „Ein einfaches Linting-Tool erstellen“?

Erstellen Sie mit der Compiler-API ein benutzerdefiniertes Diagnosewerkzeug. 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 4 von 4.

Wie lange dauert die Lektion „Ein einfaches Linting-Tool erstellen“?

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

  1. Ein TypeScript-Programm mit der API erstellen
  2. Den AST mit Visitor-Funktionen durchlaufen
  3. Benutzerdefinierte Transformer und Codegenerierung
  4. Ein einfaches Linting-Tool erstellen
← Zurück zu TypeScript Academy