TypeScript Academy · Lektion

Secrets og typesikkerhed

Håndtér følsomme værdier uden at lække dem ind i typerne

Lektion 4 af 413 trin

Secrets og typesikkerhed er en gratis TypeScript Academy-lektion på CoddyKit. Dette er lektion 4 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i TypeScript Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. TypeScript Academy-kurset indeholder 4 lektioner i alt.

Hemmeligheder kræver særlig omtanke

API-nøgler, adgangskoder og tokens er også konfiguration, men det er farligt at afsløre dem i logfiler eller fejlmeddelelser. Typning kan hjælpe med at forhindre, at hemmelige værdier bliver eksponeret ved et uheld.

Problemet med utilsigtet logning

En hemmelighed som almindelig streng kan ved et uheld blive logget hvor som helst, f.eks. via console.log(config) eller en fejludskrift, der serialiserer hele konfigurationsobjektet.

const config = { dbPassword: "hunter2" };
console.log(config); // leaks the password

Mærkede hemmelighedstyper

En mærket type markerer en streng som en hemmelighed på kompileringstidspunktet, så typesystemet skelner mellem en Secret og en almindelig streng og tvinger en bevidst håndtering.

type Secret = string & { readonly __brand: "Secret" };
function secret(s: string): Secret { return s as Secret; }

Hvorfor mærkning hjælper

Fordi en Secret ikke kan tildeles til en almindelig string uden en eksplicit hensigt, kan funktioner kræve en Secret, hvor det er relevant, og du kan ikke ved en fejl sende den et usikkert sted hen.

function connect(pw: Secret) { /* uses pw */ }
// connect("plain") -> type error; must wrap with secret()

En indpakningsklasse til hemmeligheder

Et alternativ er at indpakke værdien i en klasse, hvis toString og serialisering skjuler værdien, så selv uforsigtig logning kun viser en pladsholder.

class Secret {
  constructor(private readonly value: string) {}
  expose(): string { return this.value; }
  toString() { return "[REDACTED]"; }
}

Maskering under serialisering

Tilpasning af toJSON sikrer, at hemmeligheden aldrig vises, når et objekt serialiseres med JSON.stringify, som er den mest almindelige vej til utilsigtet lækage.

class Secret {
  constructor(private readonly value: string) {}
  expose() { return this.value; }
  toJSON() { return "[REDACTED]"; }
}
// JSON.stringify({ pw: new Secret("x") }) -> {"pw":"[REDACTED]"}

Kun eksplicit eksponering

Den rigtige værdi er kun tilgængelig gennem en eksplicit metode som expose(). Det gør hvert sted, der læser en hemmelighed, synligt og muligt at revidere i koden.

const pw = new Secret("hunter2");
console.log(String(pw)); // [REDACTED]
connectToDb(pw.expose()); // deliberate access

Hold hemmeligheder ude af brede typer

Undgå at placere rå hemmelige strenge i brede konfigurationsgrænseflader, som logges i deres helhed. Brug typen Secret, så hemmeligheder som standard maskeres, uanset hvor konfigurationen udskrives.

interface Config {
  host: string;
  dbPassword: Secret; // not a plain string
}

Sikker indlæsning af hemmeligheder

Indpak hemmelige miljøværdier, når du læser dem, så de er mærkede eller pakket ind fra første øjeblik og aldrig cirkulerer som almindelige strenge.

const config = {
  host: process.env.DB_HOST!,
  dbPassword: new Secret(process.env.DB_PASSWORD!),
};

Forsvar i dybden

Hemmeligheder på typeniveau mindsker utilsigtede lækager, men erstatter ikke god driftspraksis: Begræns, hvem der kan læse miljøvariabler, undgå at logge forespørgselsdata, og filtrér følsomme oplysninger fra fejlrapporteringssystemer.

Opsummering af teknikker

Brug brandede typer til at tvinge en bevidst håndtering, en wrapperklasse med en toString/toJSON, der maskerer værdien, og en eksplicit expose() til at læse værdien, så hemmeligheder holdes ude af logfiler og serialiserede data.

Hurtigt tjek

Et hurtigt tjek af denne lektion.

Besvar den i den interaktive lektion

Opsamling

Beskyt hemmeligheder med brandede typer (som tvinger til bevidst håndtering) eller en wrapperklasse, hvis toString/toJSON returnerer [REDACTED], så den rigtige værdi kun gøres tilgængelig via en eksplicit expose(). På den måde holdes hemmeligheder ude af logfiler og serialiseret konfiguration.

Gratis at komme i gang

Lær TypeScript med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 101
Lektioner: 352

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Secrets og typesikkerhed” gratis?

Ja — hele teksten til “Secrets og typesikkerhed” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af TypeScript Academy-kurset, skal du opgradere til CoddyKit PRO. TypeScript Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Secrets og typesikkerhed”?

Håndtér følsomme værdier uden at lække dem ind i typerne Du øver dig i TypeScript Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på TypeScript Academy?

Der kræves ingen tidligere erfaring. TypeScript Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 4 af 4.

Hvor lang tid tager lektionen “Secrets og typesikkerhed”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne TypeScript Academy-lektion?

Ja. Alle TypeScript Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til TypeScript Academy