TypeScript statiske analyseværktøjer: Den komplette guide til udviklingsteams

TypeScripts typesystem fanger en betydelig klasse af fejl før kodekørsler, typeuoverensstemmelser, manglende egenskaber, forkerte funktionssignaturer. Hvad det ikke kan fange, er alt andet: sikkerhedssårbarheder, der afhænger af, hvordan data flyder gennem applikationen, arkitektoniske overtrædelser, der akkumuleres over tid, efterhånden som teamgrænser udviskes, døde eksporter, der forbliver i kodebasen længe efter, at deres kaldere er blevet fjernet, og asynkrone programmeringsfejl, der kompilerer korrekt, men fejler under specifikke runtime-forhold. Statiske analyseværktøjer udfylder disse huller, og valget af den rigtige kombination afhænger af, hvad du rent faktisk prøver at finde.

Denne guide dækker de værktøjer, der er vigtige for TypeScript-teams i 2026: linting-laget (ESLint med typescript-eslint, Biome, OxcLint), sikkerhedslaget (Semgrep, Snyk Code, SonarQube), det arkitektoniske lag (Dependency-Cruiser, Deptrac, Nx), dead code-laget (Knip) og det dybe analyselag (ts-morph, selve TypeScript Compiler). For hver af dem er fokus på, hvad det rent faktisk gør, hvordan det konfigureres, og hvornår det ikke er det rigtige værktøj til jobbet.

TypeScript statiske analyseværktøjer: Sammenligningstabel

Før vi dykker ned i de enkelte værktøjer, kortlægger tabellen nedenfor hvert værktøj til dets primære funktion, CI-egnethed og ideelle use case. Intet enkelt værktøj dækker alle dimensioner; effektiv TypeScript-kvalitetsanalyse kræver lagdeling af flere.

Værktøj	Primær funktion	CI-egnet	Pris	bedst til
ESLint + typescript-eslint	Linting, stil, typebevidste regler	Ja	Gratis	Teamdækkende konventioner, asynkron sikkerhed
biom	Linting + formatering	Ja	Gratis	ESLint + Smukkere erstatning, hastighed
OxcLint	Linting (ESLint-kompatibel)	Ja	Gratis	Monorepos kræver hurtige fnugtider
TypeScript-compiler (tsc)	Typekontrol	Ja	Gratis	Typefejl, streng håndhævelse af tilstand
Semgrep	SAST, brugerdefinerede mønstre	Ja	Gratis + betalt	Sikkerhedsscanning, brugerdefinerede organisationsregler
Snyk kode	SAST, afhængighedssikkerhed	Ja	Gratis + betalt	Sikkerhedsfokuserede teams, IDE-integration
SonarQube / SonarCloud	Kvalitetsporte, trendsporing	Ja	Gratis + betalt	Kvalitetsdashboards for virksomheder
SonarLint	Feedback om kvalitet på IDE-niveau	Kun IDE	Gratis	Tips til indlejret sikkerhed og kvalitet
Afhængighedskrydseren	Håndhævelse af afhængighedsgraf	Ja	Gratis	Validering af arkitektoniske regler
Deptrac	Håndhævelse af laggrænser	Ja	Gratis	Ren arkitektur, DDD-grænser
Nx	Monorepo afhængighedsstyring	Ja	Gratis + betalt	Monorepo-modulgrænser
klip	Død kode og ubrugte eksportvarer	Ja	Gratis	Reduktion af ubrugt kode i stor skala
ts-morph	Programmatisk TS AST-analyse	Selektiv	Gratis	Brugerdefineret analyse, kodemods, værktøjer

Lag 1: Fnug og stil

ESLint med typescript-eslint

ESLint er fortsat fundamentet for TypeScript-linting. Med typescript-eslint pakken, får den adgang til TypeScripts typeinformation og kan håndhæve regler, der kræver typekontekst, hvoraf de mest værdifulde er de async-specifikke regler, der fanger almindelige Promise-fejl.

bash

npm install --save-dev typescript-eslint

javascript

// eslint.config.js
import tseslint from "typescript-eslint";

export default tseslint.config(
  ...tseslint.configs.strictTypeChecked,
  {
    languageOptions: {
      parserOptions: {
        project: true,
        tsconfigRootDir: import.meta.dirname,
      },
    },
    rules: {
      // Async safety rules -- highest value TypeScript-specific rules
      "@typescript-eslint/no-floating-promises": "error",
      "@typescript-eslint/await-thenable": "error",
      "@typescript-eslint/no-misused-promises": "error",
      "@typescript-eslint/require-await": "warn",
      // Type safety
      "@typescript-eslint/no-explicit-any": "warn",
      "@typescript-eslint/no-unsafe-assignment": "error",
      "@typescript-eslint/no-unsafe-return": "error",
    },
  }
);

De fire async-regler ovenfor er den mest værdifulde tilføjelse, som typescript-eslint giver i forhold til almindelig ESLint. De fanger: uhåndterede løfter (flydende løfter), await anvendt på ikke-Promise-værdier, løfter sendt til callbacks, der forventer synkrone funktioner, og asynkrone funktioner, der aldrig bruger awaitDette er mønstre, der kompilerer rent, men som producerer runtime-fejl under specifikke forhold.

Hvad ESLint ikke kan: analyse af dataflow mellem filer, håndhævelse af arkitektoniske grænser, sporing af sikkerhedspletter eller detektion af døde eksporter. For disse er de andre lag nedenfor påkrævet.

Biom: Den moderne ESLint + en smukkere erstatning

Biome erstatter både ESLint og Prettier med en enkelt Rust-baseret binær fil, der kører 25-35 gange hurtigere. Den understøtter JavaScript, TypeScript, JSX og JSON. For nye projekter eller teams, der er frustrerede over ESLints plugin-kompleksitet og langsomme ydeevne i store kodebaser, er Biome det stærkeste moderne alternativ.

bash

npm install --save-dev --save-exact @biomejs/biome
npx @biomejs/biome init

bash

# Check and format in one pass
npx @biomejs/biome check --write src/

# CI mode -- no modifications, exit non-zero on any finding
npx @biomejs/biome ci src/

Biomes plugin-økosystem er mindre end ESLints, hvilket er vigtigt for teams med omfattende brugerdefinerede regler eller framework-specifikke plugins. For teams, der kun bruger de centrale ESLint-regler og Prettier-formatering, leverer Biome tilsvarende dækning til en brøkdel af udførelsestiden.

OxcLint: Hastighed-først ESLint-kompatibilitet

OxcLint (en del af Oxc-projektet) kører ESLint-kompatible regler med 50-100 gange hurtigere udførelse. Det erstatter ikke det fulde ESLint-økosystem, men fungerer som den hurtigste mulighed for CI-pipelines, hvor lint-tid er en flaskehals.

bash

npm install --save-dev oxlint
npx oxlint src/

OxcLint er det rigtige valg til store monorepos, hvor standard ESLint tager minutter, og feedback loop latency reducerer kvaliteten af ​​pull requests. Det fungerer bedst sammen med ESLint i stedet for at erstatte det. Kør OxcLint for den hurtige feedbacksti og ESLint for fuld regeldækning i pre-merge gaten.

Lag 2: Typekontrol, TypeScript-compileren

TypeScript-compileren (tsc) er ikke bare et byggeværktøj, det er den primære statiske analysemotor til korrekthed på typeniveau. Aktivering af strict mode aktiverer de indstillinger, der fanger de fleste virkelige fejl:

json

{
  "compilerOptions": {
    "strict": true,
    "noUnusedLocals": true,
    "noUnusedParameters": true,
    "noImplicitReturns": true,
    "noFallthroughCasesInSwitch": true,
    "exactOptionalPropertyTypes": true,
    "useUnknownInCatchVariables": true
  }
}

bash

# Type-check only, no emit -- ideal for CI
npx tsc --noEmit

noUnusedLocals og noUnusedParameters på compilerniveau fange ubrugte variabler og funktionsparametre. useUnknownInCatchVariables (TypeScript 4.4+) typer fangede undtagelser som unknown snarere end any, hvilket gennemtvinger eksplicit typeindsnævring før brug.

TypeScript-kontrolflowanalyse er en indbygget funktion, som compileren tilbyder til at indsnævre typer inden for betingede grene. Det er ikke et separat værktøj, der muliggør strict tilstanden sikrer, at den anvendes med fuld stringens. Compilerens kontrolflowanalyse forstår type guards, typeof checks, instanceofog diskriminerede fagforeningsmønstre.

TSC-begrænsningenTypeScript-compileren finder ikke sikkerhedssårbarheder, overtrædelser af arkitektoniske grænser eller døde eksporter. Den finder typefejl, og den gør det definitivt.

Lag 3: Sikkerhed, SAST til TypeScript

Semgrep: Mønsterbaseret sikkerhedsscanning

Semgrep finder sikkerhedssårbarheder gennem matchning af kodemønstre. For TypeScript kan det detektere SQL-injektion, XSS, hardcodede legitimationsoplysninger, usikre eval brug, prototypeforurening og usikre Express.js-konfigurationer, mønstre der kompilerer korrekt, men introducerer sårbarheder, der kan udnyttes.

yaml

# Custom rule: flag user input in SQL queries (TypeScript)
rules:
  - id: ts-sql-injection-risk
    patterns:
      - pattern: |
          const query = `SELECT ... ${$USER_INPUT} ...`;
    message: "User input directly interpolated into SQL -- use parameterized queries"
    languages: [typescript]
    severity: ERROR

bash

# Run with the community TypeScript security rules
semgrep scan --config=p/typescript --config=p/owasp-top-ten src/

Semgrep supplerer ESLint, ikke konkurrerer med det. ESLint håndhæver konventioner; Semgrep finder sikkerheds-antimønstre. De fleste TypeScript-teams, der bekymrer sig om sikkerhed, bør køre begge dele.

Snyk-kode: ML-baseret SAST med IDE-integration

Snyk Code udfører SAST med en maskinlæringsbaseret analysemotor, der sporer taint-flows på tværs af filer. Den integreres i VS Code og JetBrains IDE'er og viser resultater inline, når udviklere skriver kode, i stedet for at vente på en CI-kørsel.

bash

npm install --save-dev snyk
npx snyk auth
npx snyk code test

Snyk Codes fokus på udvikleroplevelsen, indlejrede IDE-feedback, forslag til rettelser ved siden af ​​hvert fund og eksempler på afhjælpning gør det til det bedre valg, når sikkerhedsuddannelse er lige så vigtig som sikkerhedsdetektion.

SonarQube og SonarLint: Kvalitetsporte og trendsporing

SonarQube leverer kontinuerlig analyse af kodekvalitet med et dashboard, trendsporing og dekoration af pull requests. For TypeScript registrerer det fejl, kodelugt, sikkerhedshotspots og duplikater. SonarLint er IDE-udvidelsen, der lokalt viser SonarQube-regler.

For TypeScript-teams er SonarCloud (den cloud-hostede version) den enklere løsning: gratis til offentlige repositories, med CI-integration via GitHub Actions eller GitLab CI på få minutter.

yaml

# .github/workflows/sonar.yml
- name: SonarCloud Scan
  uses: SonarSource/sonarcloud-github-action@master
  env:
    GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
    SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}

SonarQubes primære værdi i forhold til raw linting er dens trendmodel: hvordan udvikler kodekvaliteten sig over tid, hvilke komponenter forringes, og hvad er den nye kodekvalitets gate-score for hver pull request. Disse ledelsesrettede målinger er, hvad SonarQube gør, som ESLint og Semgrep ikke kan.

Lag 4: Arkitektonisk analyse

Afhængighedskryds: Håndhæv modulgrænseregler

Dependency-Cruiser validerer, at din importgraf følger definerede arkitektoniske regler. Den genererer visuelle afhængighedsgrafer og fejler CI, når kode overtræder modulgrænsebegrænsninger.

javascript

// .dependency-cruiser.cjs
module.exports = {
  forbidden: [
    {
      name: "no-circular",
      severity: "error",
      comment: "Circular dependencies make code hard to test and maintain",
      from: {},
      to: { circular: true },
    },
    {
      name: "no-ui-in-domain",
      severity: "error",
      comment: "Domain modules must not import from UI layer",
      from: { path: "^src/domain" },
      to: { path: "^src/ui" },
    },
    {
      name: "no-external-in-shared",
      severity: "warn",
      comment: "Shared utilities should minimize external dependencies",
      from: { path: "^src/shared" },
      to: { pathNot: "^(src|node_modules/(lodash|date-fns))" },
    },
  ],
};

bash

npx depcruise --validate .dependency-cruiser.cjs src/

Dependency-Cruiser adresserer direkte forespørgslerne "react dependency analysis cli tool" i Search Console-dataene. Det er standardværktøjet til at generere og validere afhængighedsgrafer i TypeScript/React-projekter.

Deptrac: Lagbaseret grænsehåndhævelse

Deptrac håndhæver arkitektoniske lag og sikrer, at persistenskode ikke kan importeres fra præsentationen, at domæneobjekter ikke er afhængige af infrastruktur, og at modulgrænser respekteres på tværs af hele kodebasen.

yaml

# deptrac.yaml
parameters:
  layers:
    - name: Domain
      collectors:
        - type: directory
          value: src/domain
    - name: Application
      collectors:
        - type: directory
          value: src/application
    - name: Infrastructure
      collectors:
        - type: directory
          value: src/infrastructure
  ruleset:
    Domain:
      - ~Infrastructure  # Domain must not depend on Infrastructure
    Application:
      - Domain
    Infrastructure:
      - Application
      - Domain

Deptrac er mest værdifuld i projekter, der følger Clean Architecture-, DDD- eller Hexagonal Architecture-mønstre, hvor lagisolering er en designbegrænsning, ikke blot en præference.

Nx: Afhængighedsstyring på Monorepo-niveau

For TypeScript-monorepos leverer Nx håndhævelse af modulgrænser, detektion af affekterede builds og visualisering af afhængighedsgrafer på tværs af alle projekter i repository'et.

json

// .eslintrc.json -- Nx module boundary rules
{
  "rules": {
    "@nx/enforce-module-boundaries": [
      "error",
      {
        "allow": [],
        "depConstraints": [
          { "sourceTag": "scope:shared", "onlyDependOnLibsWithTags": ["scope:shared"] },
          { "sourceTag": "scope:feature", "onlyDependOnLibsWithTags": ["scope:shared", "scope:feature"] },
          { "sourceTag": "scope:app", "onlyDependOnLibsWithTags": ["scope:shared", "scope:feature"] }
        ]
      }
    ]
  }
}

Nx'er affected Kommandoer kører kun de tests og linting-funktioner, der er relevante for ændrede moduler, hvilket reducerer CI-tiden i store monorepos betydeligt.

Lag 5: Detektion af død kode

Knip: Find ubrugte eksporter, filer og afhængigheder

Knip analyserer hele modulgrafen for at identificere ubrugte eksporter, ubrugte filer og ubrugte package.json afhængigheder, den klasse af kodeakkumulering, som ESLints no-unused-vars kan ikke fange, fordi den kun kigger i en fil.

bash

npm install --save-dev knip
npx knip

json

// knip.json
{
  "entry": ["src/index.ts", "src/**/*.test.ts"],
  "project": ["src/**/*.ts"],
  "ignore": ["src/generated/**"],
  "ignoreDependencies": ["vitest"]
}

Knip søges direkte i SC-dataene som "death code detection unused exports javascript typescript." Det er det mest kapable nuværende værktøj til identifikation af død kode på modulniveau i TypeScript-projekter.

Lag 6: Programmatisk analyse, ts-morph

ts-morph er en TypeScript compiler API-wrapper, der gør det nemt at skrive brugerdefineret analyse, codemods og værktøjer mod TypeScript AST. Den søges direkte i SC-dataene som "ts-morph" og "ts morph".

maskinskrift

import { Project } from "ts-morph";

const project = new Project({ tsConfigFilePath: "tsconfig.json" });

// Find all async functions that never await anything
const suspiciousAsyncFns: string[] = [];

for (const sourceFile of project.getSourceFiles()) {
  for (const fn of sourceFile.getFunctions()) {
    if (fn.isAsync()) {
      const hasAwait = fn.getDescendantsOfKind(
        SyntaxKind.AwaitExpression
      ).length > 0;
      if (!hasAwait) {
        suspiciousAsyncFns.push(
          `${sourceFile.getFilePath()}:${fn.getName() ?? "anonymous"}`
        );
      }
    }
  }
}

console.log("Async functions with no await:", suspiciousAsyncFns);

ts-morph er ikke et færdigt analyseværktøj, det er det bibliotek, du bruger til at bygge et. Det er passende for teams, der har brug for brugerdefineret analyse ud over, hvad eksisterende værktøjer understøtter: migreringsscripts, brugerdefinerede arkitekturvalidatorer, automatiseret refactoring eller kodegenereringspipelines.

TypeScript Async/Avvent statisk analyse

Search Console-dataene viser en specifik klynge af forespørgsler omkring "typescript static analysis async await paper tool" og "typescript static analysis async await vulnerability paper tool". Disse afspejler praktikere, der søger efter værktøjer, der forstår async-programmeringsfejl på typeniveau.

Det praktiske svar for produktionsteams i TypeScript er typescript-eslints fire asynkronspecifikke regler (no-floating-promises, await-thenable, no-misused-promises, require-await) kombineret med strictNullChecks og useUnknownInCatchVariablesSammen fanger disse de mest almindelige asynkrone fejl uden at kræve akademiske forskningsværktøjer.

For teams, der udfører sikkerhedsresearch på asynkrone sårbarhedsmønstre, er TAJS og Jelly akademiske statiske analysatorer, der modellerer JavaScripts asynkrone udførelsessemantik, men de er forskningsværktøjer, ikke produktionsudviklingsværktøjer.

Angular og React: Framework-specifik statisk analyse

For Angular-teams, @angular-eslint Leverer Angular-specifikke linting-regler, der dækker komponentmønstre, skabelonanalyse og serviceinjektion. Den integrerer med ESLint + typescript-eslint-konfigurationen ovenfor.

For React-teams, eslint-plugin-react, eslint-plugin-react-hooksog eslint-plugin-jsx-a11y Plugins dækker React-specifikke mønstre. Dependency-Cruiser håndterer React-specifik afhængighedsgrafanalyse og er værktøjet bag "react dependency analysis cli tool"-forespørgslerne i SC-dataene.

IDE-integration: Værktøjer til VS Code og JetBrains

Forespørgslerne "værktøjer af topkodekvalitet til VS-kodeintegration" og "værktøjer af topkodekvalitet til IDE-integration" afspejler et reelt behov: CI-feedback kommer for sent til at ændre adfærd. IDE-integreret analyse giver den tætteste feedback-loop.

VS-kodeESLint-udvidelse med rust-analysator Clippy-paritet, SonarLint-udvidelse til indlejrede SonarQube-regler, Snyk-udvidelse til sikkerhedsfund og den indbyggede TypeScript-sprogtjeneste til feedback på typeniveau.

JetBrains (WebStorm/IntelliJ)WebStorm leveres med indbygget TypeScript-understøttelse, der afslører typefejl inline, plus integration med ESLint, Prettier og SonarLint. Det indbyggede inspektionssystem dækker mange af de samme mønstre som ESLint-regler.

VS Code-konfiguration for maksimal dækning af statisk TypeScript-analyse:

json

// .vscode/settings.json
{
  "typescript.tsdk": "node_modules/typescript/lib",
  "typescript.enablePromptUseWorkspaceTsdk": true,
  "editor.codeActionsOnSave": {
    "source.fixAll.eslint": "explicit"
  },
  "eslint.validate": ["javascript", "typescript", "typescriptreact"],
  "sonarlint.connectedMode.project": {
    "connectionId": "my-sonarcloud",
    "projectKey": "my-org_my-project"
  }
}

Hvordan SMART TS XL Udvider TypeScript-analyse på tværs af virksomheden

Ovenstående værktøjer dækker TypeScript inden for et TypeScript-projekt. I organisationer, hvor TypeScript-tjenester interagerer med COBOL-batchprogrammer, Java API'er, Python-datapipelines eller ældre mainframe-systemer, kan enkeltsprogede værktøjer ikke se afhængigheder, der krydser sproggrænser.

SMART TS XL's statisk kodeanalyse dækker TypeScript sammen med alle andre sprog i virksomhedsmiljøet, COBOL, JCL, Java, Python, RPG, SQL, og opbygger en samlet afhængighedsmodel på tværs af dem alle. Når en TypeScript-tjeneste kalder en API, der er understøttet af et COBOL-program, SMART TS XL kan spore den relation og inkludere den i konsekvensanalyse før der foretages nogen ændring af nogen af ​​komponenterne.

virksomhedssøgning Funktionen gør hele den flersprogede kodebase forespørgbar: find hver TypeScript-import af et specifikt modul, hver Java-metode, som en TypeScript-tjeneste kalder, hver COBOL-kopibog, der sender data til en TypeScript-forbrugt API, på få sekunder, på tværs af millioner af linjer kode i enhver kombination af sprog.

For virksomhedsteams, der bruger TypeScript som ét sprog i en større portefølje, SMART TS XL giver arkitektonisk synlighed og tværfaglighed afhængighedskortlægning der får TypeScript-specifikke værktøjer til at se på deres del af systemet, mens SMART TS XL ser helheden.

Opbygning af den rigtige stak

Intet enkelt værktøj dækker alle kvalitetsdimensioner for TypeScript. Den rigtige tilgang er lagdelt, hvor hvert lag er rettet mod en specifik problemklasse:

Minimum levedygtig stak (nyt projekt, lille team):

• TypeScript streng tilstand
• ESLint med Typescript-eslint asynkrone regler
• npm audit for afhængighedssårbarheder

Produktionsapplikationsstak (mellemstort hold, sikkerhedsbevidst):

• Alt ovenover plus:
• Biom eller Pænere til formatering
• Semgrep til sikkerheds-SAST
• Knip efter død kode
• SonarCloud for synlighed af kvalitetstrends

Enterprise / monorepo-stak (stort team, arkitektoniske begrænsninger):

• Alt ovenover plus:
• Afhængighedskrydsningsværktøj til håndhævelse af modulgrænser
• Nx til optimering af affekteret build fra monorepo
• Deptrac til validering af laggrænser
• SonarQube (selvhostet) til lokale kvalitetsporte

Polyglot virksomhedsstak (TypeScript sammen med ældre systemer):

• Alt ovenover plus:
• SMART TS XL til tværsproglig konsekvensanalyse og afhængighedskortlægning