Ty­pe­Script har en række vigtige funk­tio­ner, der fun­da­men­talt forbedrer ud­vik­lin­gen af we­bap­pli­ka­tio­ner. Denne Ty­pe­Script-tutorial giver dig en in­tro­duk­tion til pro­gram­me­rings­spro­get og forklarer nogle af dets vigtigste funk­tio­ner og an­ven­del­ser samt dets fordele og ulemper.

Hvad er Ty­pe­Script?

Ty­pe­Script er udviklet af Microsoft og bygger på pro­gram­me­rings­spro­get Ja­va­Script, som er meget udbredt inden for we­b­ud­vik­ling. En af de mest frem­træ­den­de egen­ska­ber ved Ty­pe­Script er statisk typning. I mod­sæt­ning til Ja­va­Script, som har dynamisk typning, giver Ty­pe­Script mulighed for at deklarere datatyper for variabler, funk­tio­ner og parametre. Dette gør det muligt at opdage kod­nings­fejl på et tidligt tidspunkt, så fejlene kan iden­ti­fi­ce­res, inden koden er blevet udført. Statisk typning forbedrer ikke kun ko­de­kva­li­te­ten be­ty­de­ligt, men også kodens læsbarhed.

Ty­pe­Script-syntaksen er næsten identisk med Ja­va­Script, hvilket gør det meget nemmere at integrere den i ek­si­ste­ren­de Ja­va­Script-projekter. Faktisk er Ty­pe­Script en supersæt af Ja­va­Script, hvilket betyder, at enhver Ja­va­Script-kode, der er korrekt, også er gyldig Ty­pe­Script-kode. Dette giver dig mulighed for gradvist at migrere til Ty­pe­Script og drage fordel af fordelene ved statisk typning og andre funk­tio­ner uden at skulle omskrive din ek­si­ste­ren­de kodebase fuld­stæn­digt.

Her er et simpelt Ja­va­Script-eksempel:

function greet(name) {
    return "Hello, " + name;
}
console.log(greet(123)); // Output: "Hello, 123"
ja­va­script

I oven­stå­en­de kode er funk­tio­nen greet ikke begrænset til en bestemt datatype for pa­ra­me­te­ren name. Det betyder, at funk­tio­nen stadig vil fungere, selvom vi overfører et tal som argument.

I Ty­pe­Script kan koden se sådan ud:

function greet(name: string): string {
    return "Hello, " + name;
}
console.log(greet(123)); // Error in TypeScript
ty­pe­script

Her har vi de­kla­re­ret pa­ra­me­te­ren name som en streng. Hvis vi forsøger at bruge funk­tio­nen med et tal, vil Ty­pe­Script vise en fejl, fordi den overførte datatype ikke matcher den for­ven­te­de datatype.

Dette eksempel viser, hvordan Ty­pe­Script hjælper med at opdage fejl tidligt i forløbet og forbedrer kodens kvalitet ved at forhindre forkert brug af datatyper. Det er vigtigt at bemærke, at Ty­pe­Script til sidst kom­pi­le­res til Ja­va­Script, hvilket gør det muligt at køre det i ethvert Ja­va­Script-miljø. Dette betyder dog, at du kun får fordelene ved ty­pe­sik­ker­hed i ud­vik­lings­fa­sen.

Hvad bruges Ty­pe­Script til?

Ty­pe­Script er uund­vær­ligt inden for for­skel­li­ge områder af softwa­re­ud­vik­ling, især i si­tu­a­tio­ner hvor ty­pe­sik­ker­hed og ko­de­kva­li­tet er af afgørende betydning.

Et frem­træ­den­de an­ven­del­ses­om­rå­de for Ty­pe­Script er we­b­ud­vik­ling. Her sikrer Ty­pe­Script, at Ja­va­Script-kode skrives på en måde, der gør den mere sikker og lettere at ved­li­ge­hol­de. Dette er en fordel i om­fat­ten­de frontend-projekter med komplekse kodebaser. Ty­pe­Script kan dog også im­ple­men­te­res på ser­ver­si­den (backend) i Node.js-ap­pli­ka­tio­ner for at give et ekstra sik­ker­heds­lag. I ser­ver­lø­se ar­ki­tek­tu­rer som AWS Lambda og Azure Functions hjælper Ty­pe­Script med at minimere fejl og sikre pålidelig udførelse.

Udvikling på tværs af platforme er endnu et område, hvor Ty­pe­Script viser sine styrker. Det kan optimere ap­pli­ka­tio­ner på tværs af platforme og udvikling af mobile apps be­ty­de­ligt. Fra­mewor­ks som Na­ti­ve­Script og React Native tilbyder support til Ty­pe­Script, når det kommer til pro­gram­me­ring af mobile apps til for­skel­li­ge platforme. I spil­ud­vik­ling anvendes Ty­pe­Script i projekter, der bruger WebGL eller spil-engines som Phaser eller Babylon.js. Ty­pe­Scripts ty­pe­sik­ker­hed hjælper med at forbedre spillets kvalitet og ved­li­ge­hol­del­se.

Ty­pe­Script bruges også til da­ta­vi­su­a­li­se­ring og ana­ly­se­pro­jek­ter. Bi­bli­o­te­ker som D3.js un­der­støt­ter Ty­pe­Script og gør det muligt at oprette so­fi­sti­ke­re­de das­h­bo­ards og vi­su­a­li­se­rin­ger.

Sådan in­stal­le­res Ty­pe­Script

Det er nemt at in­stal­le­re Ty­pe­Script, og det kræver kun få trin. Hvis du har Node.js på din computer, kan du in­stal­le­re Ty­pe­Script med npm (Node Package Manager).

Trin 1: Download Node.js

Kon­trol­ler, om du har Node.js in­stal­le­ret på din computer. Hvis du endnu ikke har in­stal­le­ret Node.js, kan du downloade og in­stal­le­re det fra den of­fi­ci­el­le hjem­mesi­de.

Trin 2: Installer Ty­pe­Script i ter­mi­na­len

Åbn din kom­mandoprompt (f.eks. Kom­mandoprompt i Windows eller ter­mi­na­len på macOS eller Linux) og indtast følgende kommando for at in­stal­le­re Ty­pe­Script globalt:

npm install -g typescript
bash

Flagget -g (global) in­stal­le­rer Ty­pe­Script på hele dit system, så du kan bruge det hvor som helst.

Trin 3: Kon­trol­ler den in­stal­le­re­de version

Du kan teste, om in­stal­la­tio­nen var vellykket, ved at udføre følgende kommando:

tsc -v
bash

Denne kommando viser, hvilken version af Ty­pe­Script der er in­stal­le­ret. Hvis der vises et ver­sions­num­mer, betyder det, at in­stal­la­tio­nen er gen­nem­ført.

Efter in­stal­la­tio­nen kan du generere Ja­va­Script-filer ved at oprette Ty­pe­Script-filer (med fil­ty­pe­nav­net .ts) og kompilere dem med Ty­pe­Script-kom­pi­la­to­ren tsc.

Trin 4: Opret en Ty­pe­Script-fil

Opret en Ty­pe­Script-fil, f.eks. app.ts, og indsæt din Ty­pe­Script-kode.

type Person = { name: string, age: number };
const alice: Person = { name: "Alice", age: 30 };
console.log(`Hello, I am ${alice.name} and I am ${alice.age} years old.`);
ty­pe­script

Trin 5: Kompiler filen

Kompiler Ty­pe­Script-filen ved at indtaste følgende kommando:

tsc app.ts
bash

Dette vil kompilere app.ts til en Ja­va­Script-fil med navnet app.js. Du kan derefter køre Ja­va­Script-filen.

Hvilke funk­tio­ner har Ty­pe­Script?

We­b­ud­vik­ling har gjort be­ty­de­li­ge frem­skridt i de senere år, og Ty­pe­Script er fremstået som et yderst effektivt al­ter­na­tiv til Ja­va­Script. Nedenfor har vi sam­men­fat­tet de vigtigste funk­tio­ner i dette sprog.

Statisk typning

Statisk typning er en vigtig funktion i Ty­pe­Script, der giver dig mulighed for at angive datatyper for variabler, parametre, funk­tio­ner og andre elementer i din kode. I mod­sæt­ning til dynamisk typning i Ja­va­Script, hvor datatyper bestemmes under ud­fø­rel­sen, tildeles datatyper i Ty­pe­Script under ud­vik­lin­gen, inden koden udføres. Denne metode hjælper med at iden­ti­fi­ce­re fejl og logiske problemer på et tidligt tidspunkt.

function add(a: number, b: number): number {
    return a + b;
}
const result = add(5, 3); // valid
const result = add(5, "3"); // Type Error
ty­pe­script

I dette eksempel har vi brugt statisk typning til funk­tio­nen add. De to parametre a og b er de­kla­re­ret som tal (number), og funk­tio­nen re­tur­ne­rer en værdi af typen number. Ethvert forsøg på at bruge denne funktion med en anden datatype vil få Ty­pe­Script til at iden­ti­fi­ce­re det som en fejl.

Valgfri ind­tast­ning

Med valgfri typning har du mulighed for at angive datatyper for bestemte variabler og parametre, mens andre kan forblive uden en defineret datatype.

function sayHello(name: string, age: any): string {
    if (age) {
        return `Hello, ${name}, you are ${age} years old.`;
    } else {
        return `Hello, ${name}.`;
    }
}
ty­pe­script

Funk­tio­nen sayHello er defineret med pa­ra­me­tre­ne name og age. Be­teg­nel­sen any angiver, at pa­ra­me­te­ren age kan være af enhver datatype.

ES6+-funk­tio­ner

Ty­pe­Script un­der­støt­ter moderne Ja­va­Script-funk­tio­ner, herunder ES6 og nyere funk­tio­ner såsom pil­funk­tio­ner og ska­be­lon­stren­ge.

const multiply = (a: number, b: number): number => a * b;
const greeting = (name: string) => `Hello, ${name}!`;
ty­pe­script

Pil­funk­tio­ner­ne fører til en kortere og mere præcis syntaks.

Ko­de­struk­tur

Ty­pe­Script tilbyder bedre ko­de­struk­tu­re­ring og sikrer, at koden opdeles i gen­an­ven­de­li­ge dele. Dette er muligt takket være moduler og nav­ne­om­rå­der.

// Math.ts
export function add(a: number, b: number): number {
    return a + b;
}
// Main.ts
import { add } from './Math';
const result = add(5, 3);
ty­pe­script

Her viser vi, hvordan man struk­tu­re­rer kode med moduler og bruger import og export til or­ga­ni­se­ring. Funk­tio­nen add er defineret i et særskilt modul ved navn Math.ts og derefter im­por­te­ret og in­te­gre­ret i et andet modul, Main.ts.

Ob­jekt­o­ri­en­te­ret pro­gram­me­ring (OOP)

Ty­pe­Script letter ob­jekt­o­ri­en­te­ret pro­gram­me­ring gennem Ty­pe­Script-klasser, græn­se­fla­der og arv:

class Person {
    constructor(public name: string, public age: number) {}
    greet() {
        console.log(`Hello, my name is ${this.name} and I'm ${this.age} years old.`);
    }
}
const person = new Person("Alice", 30);
person.greet();
ty­pe­script

Dette eksempel viser brugen af klasser og ob­jekt­o­ri­en­te­ret pro­gram­me­ring (OOP) i Ty­pe­Script. Klassen Person har egen­ska­ber­ne name, age og en metode greet, som bruges til at in­tro­du­ce­re personen og give op­lys­nin­ger om ved­kom­men­de.

Udvidet ty­pe­sy­stem

Ty­pe­Script-ty­pe­sy­ste­met er flek­si­belt og om­fat­ten­de. Du kan oprette bru­ger­de­fi­ne­re­de typer og græn­se­fla­der og endda udvide ek­si­ste­ren­de typer.

interface Animal {
    name: string;
}
 
interface Dog extends Animal {
    breed: string;
}
const myDog: Dog = { name: "Buddy", breed: "Labrador" };
ty­pe­script

Græn­se­fla­den Animal definerer en egenskab name, mens græn­se­fla­den Dog arver fra Animal og tilføjer en yder­li­ge­re egenskab breed. Objektet myDog har ka­rak­te­ri­sti­ka­e­ne fra begge græn­se­fla­der.

Kom­pa­ti­bi­li­tet med Ja­va­Script

Ty­pe­Script er kom­pa­ti­belt med Ja­va­Script, hvilket gør det muligt at køre det i ethvert Ja­va­Script-miljø. Denne kom­pa­ti­bi­li­tet gør det lettere at integrere Ty­pe­Script gradvist i ek­si­ste­ren­de Ja­va­Script-projekter.

// JavaScript-Code
function greet(name) {
    return "Hello, " + name;
}
// TypeScript-Code
function greet(name: string): string {
    return "Hello, " + name;
}
ty­pe­script

Oven­stå­en­de Ja­va­Script-kode (uden ty­pi­fi­ce­ring) kan uden problemer bruges i en Ty­pe­Script-kode (med ty­pi­fi­ce­ring).

Hvad er fordelene og ulemperne ved Ty­pe­Script?

Ty­pe­Script har en række fordele, men også nogle ulemper. Her er en oversigt:

Fordele

Ty­pe­Script har et om­fat­ten­de økosystem af ty­pe­de­fi­ni­tio­ner til mange Ja­va­Script-bi­bli­o­te­ker og -fra­mewor­ks. Dette gør in­te­gra­tio­nen af tred­je­part­s­ko­de i Ty­pe­Script-projekter pro­blem­fri og ligetil. Dette er nyttigt i dagens verden af web­ba­se­re­de ap­pli­ka­tio­ner, der ofte er afhængige af flere bi­bli­o­te­ker og fra­mewor­ks.

Ud over statisk typning tilbyder Ty­pe­Script en lang række ud­vik­lings­funk­tio­ner, herunder græn­se­fla­der, klasser, moduler og un­der­støt­tel­se af aktuelle EC­MA­Script-stan­dar­der. Disse funk­tio­ner forbedrer kodens struktur, letter ved­li­ge­hol­del­sen og ska­ler­bar­he­den af projekter og fremmer pro­duk­ti­vi­te­ten i ud­vik­lin­gen. Mange in­te­gre­re­de ud­vik­lings­mil­jø­er (IDE’er) såsom Visual Studio Code yder frem­ra­gen­de support til Ty­pe­Script.

Ulemper

Ty­pe­Script tager tid at vænne sig til, især for udviklere, der kun har arbejdet med Ja­va­Script, før de begyndte at bruge det. Ty­pe­Script-kode skal kom­pi­le­res i Ja­va­Script, før den kan udføres i browsere eller Node.js-miljøer. Dette skaber et ekstra trin i ud­vik­lings­pro­ces­sen.

I mindre projekter kan Ty­pe­Script opleves som alt for kom­pli­ce­ret, da fordelene ved ty­pe­sik­ker­hed måske ikke er så tydelige. Ty­pe­Script-projekter kan kræve flere res­sour­cer på grund af yder­li­ge­re ty­pe­op­lys­nin­ger og kom­pi­le­rings­skridt.

Hvad er nogle al­ter­na­ti­ver til Ty­pe­Script?

Der findes for­skel­li­ge webpro­gram­me­rings­sprog, der kan være et godt al­ter­na­tiv til Ty­pe­Script, afhængigt af pro­jek­tets spe­ci­fik­ke krav og ud­vik­le­rens/ud­vik­ler­nes præ­fe­ren­cer.

  • Flow: Flow er en statisk ty­pe­kon­trol til Ja­va­Script, der er udviklet af Facebook. Den giver dig mulighed for at tilføje typer til Ja­va­Script-kode uden at skulle skifte helt til Ty­pe­Script. Flow er et godt valg, hvis du gradvist vil integrere typning i dine Ja­va­Script-projekter.
  • Dart: Dette er et pro­gram­me­rings­sprog udviklet af Google, der kan bruges til at oprette we­bap­pli­ka­tio­ner og mobile apps. Det tilbyder ty­pe­sik­ker­hed og god ydeevne. Dart bruges ofte i kom­bi­na­tion med Flutter-rammen til udvikling af mobile apps.
  • Pu­reScript: Pu­reScript er et stærkt ty­pe­be­stemt funk­tio­nelt pro­gram­me­rings­sprog, der in­klu­de­rer stærk ty­pe­sik­ker­hed og en rent funk­tio­nel pro­gram­me­rings­stil. Det gør det muligt at importere Ja­va­Script-bi­bli­o­te­ker.
  • Elm: Elm er et funk­tio­nelt, stærkt ty­pe­be­stemt sprog designet til udvikling af weyb-ap­pli­ka­tio­ner. Elm fremmer prin­cip­pet om Elm Ar­chi­tec­tu­re og har et højt niveau af ty­pe­sik­ker­hed.
  • ReasonML (Buck­leScript): Dette sprog er udviklet af Facebook og er baseret på OCaml. Buck­leScript er en kom­pi­la­tor, der kom­pi­le­rer ReasonML til Ja­va­Script. Det muliggør også ty­pe­sik­ker­hed og er let at integrere med React til frontend-udvikling.
Tip

Vi går mere i dybden med andre emner såsom Ty­pe­Script-funk­tio­ner og Ty­pe­Script-arrays i andre artikler i vores digitale guide.

Gå til ho­ved­me­nu­en