TypeScript-funktioner: Hur man använder parametrar och returtyper

Funktioner är byggstenarna i alla programmeringsspråk, och TypeScript förbättrar dem genom att lägga till typsäkerhet. Genom att definiera typer för parametrar och returvärden tillåter TypeScript utvecklare att skriva mer tillförlitlig och underhållbar kod. Den här guiden kommer att introducera dig till TypeScript-funktioner, som täcker hur du använder parametrar och returtyper effektivt.

Definiera en funktion i TypeScript

I TypeScript kan funktioner definieras med nyckelordet function, liknande JavaScript. Men med TypeScript kan du specificera typerna av parametrar och returvärden för ytterligare säkerhet och läsbarhet.

Exempel på grundläggande funktion

Här är ett exempel på en grundläggande TypeScript-funktion med inskrivna parametrar och en returtyp:

function add(a: number, b: number): number {
  return a + b;
}

const result = add(5, 3); // Output: 8

I det här exemplet accepterar funktionen add två parametrar av typen number och returnerar ett värde av typen number. Detta säkerställer att både input och output överensstämmer med de förväntade typerna.

Funktionsparametrar i TypeScript

TypeScript-funktioner kan acceptera olika typer av parametrar, såsom valfria parametrar, standardparametrar och viloparametrar. Låt oss utforska varje typ i detalj.

Valfria parametrar

Du kan definiera valfria parametrar genom att lägga till en ? efter parameternamnet. Valfria parametrar behöver inte anges när funktionen anropas.

function greet(name: string, age?: number): string {
  if (age) {
    return `Hello, ${name}. You are ${age} years old.`;
  } else {
    return `Hello, ${name}.`;
  }
}

console.log(greet("Alice")); // Output: Hello, Alice.
console.log(greet("Bob", 25)); // Output: Hello, Bob. You are 25 years old.

I det här exemplet är parametern age valfri. Funktionen fungerar korrekt oavsett om age tillhandahålls eller inte.

Standardparametrar

Med standardparametrar kan du ange standardvärden för parametrar om de inte tillhandahålls när funktionen anropas.

function multiply(a: number, b: number = 2): number {
  return a * b;
}

console.log(multiply(5)); // Output: 10
console.log(multiply(5, 3)); // Output: 15

I det här exemplet har parametern b ett standardvärde på 2. Om inget andra argument tillhandahålls kommer 2 att användas som standard.

Vila parametrar

Med viloparametrar kan du skicka ett varierande antal argument till en funktion. De definieras med syntaxen ....

function sum(...numbers: number[]): number {
  return numbers.reduce((total, num) => total + num, 0);
}

console.log(sum(1, 2, 3, 4)); // Output: 10
console.log(sum(5, 10, 15)); // Output: 30

I det här exemplet accepterar funktionen summa valfritt antal argument, alla av typen tal, och returnerar deras summa.

Returnera typer i TypeScript

Att specificera returtypen för en funktion är lika viktigt som att definiera parametertyper. Det hjälper TypeScript att förstå den förväntade produktionen av funktionen, vilket säkerställer att den returnerar rätt typ av data.

Ange returtyper

För att ange returtypen för en funktion, lägg till ett kolon : följt av typen efter parameterlistan.

function isEven(num: number): boolean {
  return num % 2 === 0;
}

console.log(isEven(4)); // Output: true
console.log(isEven(5)); // Output: false

I det här exemplet returnerar funktionen isEven en boolean som anger om det inmatade talet är jämnt eller inte.

Funktioner utan returtyp

När en funktion inte returnerar ett värde är dess returtyp void. Detta är användbart för funktioner som utför en åtgärd utan att ge ett resultat.

function logMessage(message: string): void {
  console.log(message);
}

logMessage("Hello, TypeScript!"); // Output: Hello, TypeScript!

I det här exemplet loggar logMessage-funktionen ett meddelande till konsolen och returnerar ingenting, därför är returtypen void.

Slutsats

TypeScript-funktioner ger ett kraftfullt sätt att skriva typsäker kod genom att definiera parametertyper och returtyper. Genom att använda valfria, standard- och viloparametrar, samt ange returtyper, kan du skapa mer robusta och underhållbara funktioner. Börja använda TypeScript-funktioner i dina projekt för att säkerställa bättre kodkvalitet och säkerhet.