Indbyggede funktioner i TypeScript

Denne artikel forklarer indbyggede funktioner i TypeScript.

YouTube Video

Indbyggede funktioner i TypeScript

Indbyggede funktioner i TypeScript er praktiske funktioner, der gør det muligt at udføre daglige operationer på en kortfattet måde. Disse er standard JavaScript-funktioner med tilføjet typesikkerhed, hvilket gør dem særligt nyttige, når der kodes i TypeScript. Her vil vi forklare nogle vigtige indbyggede funktioner, deres anvendelse og typespecifikation i detaljer.

Hvad er indbyggede funktioner?

TypeScripts indbyggede funktioner er baseret på standard JavaScript-funktioner. Ved at anvende TypeScripts typesystem forbedres typekontrol og autoudfyldning. De vigtigste funktioner inkluderer følgende:.

• parseInt()
• parseFloat()
• isNaN()
• isFinite()
• Number()
• String()
• Array()
• Array.isArray()
• eval()
• encodeURI()
• decodeURI()
• setTimeout()
• setInterval()

Disse funktioner bruges bredt i TypeScript-projekter til kortfattet datakonvertering og evaluering.

parseInt()

parseInt() er en funktion, der bruges til at konvertere en streng til et heltal. Du kan angive radix (såsom binær, decimal) som det andet argument. I TypeScript kan du specificere typen som følger:.

 1function stringToInt(value: string, radix: number = 10): number {
 2    const result: number = parseInt(value, radix);
 3    if (isNaN(result)) {
 4        throw new Error('Invalid number format');
 5    }
 6    return result;
 7}
 8
 9console.log(stringToInt("42")); // 42
10console.log(stringToInt("101010", 2)); // 42 (converted from binary)

• Angiv, at input er en streng med value: string
• Returværdien specificeres eksplicit som typen number.

parseFloat()

parseFloat() er en funktion, der bruges til at konvertere en streng til et flydende punkt-tal.

 1function stringToFloat(value: string): number {
 2    const result: number = parseFloat(value);
 3    if (isNaN(result)) {
 4        throw new Error('Invalid number format');
 5    }
 6    return result;
 7}
 8
 9console.log(stringToFloat("3.14")); // 3.14
10console.log(stringToFloat("2.71828")); // 2.71828

• parseFloat() kan korrekt fortolke tal, der inkluderer decimalpunkter.
• Ved at specificere typen kan du få en advarsel under typekontrol, hvis input ikke er et tal.

isNaN()

isNaN() er en funktion, der afgør, om den angivne værdi er NaN (Not-a-Number). Et eksempel på anvendelse i TypeScript er som følger:.

1function checkNaN(value: unknown): boolean {
2    return isNaN(Number(value));
3}
4
5console.log(checkNaN("hello")); // true
6console.log(checkNaN(123)); // false

• unknown-typen er en generisk type, der kan acceptere enhver type.
• Konverter til et tal ved at bruge Number()-funktionen, og kontroller, om resultatet er NaN.

isFinite()

isFinite() afgør, om en værdi er endelig.

1function isValueFinite(value: unknown): boolean {
2    return isFinite(Number(value));
3}
4
5console.log(isValueFinite("100")); // true
6console.log(isValueFinite(Infinity)); // false

• Denne funktion bruger også Number()-funktionen til at konvertere værdien til et tal, før den afgør det.

Number()

Number()-funktionen konverterer strenge eller booleske værdier til tal.

1function convertToNumber(value: string | boolean): number {
2    return Number(value);
3}
4
5console.log(convertToNumber("42")); // 42
6console.log(convertToNumber(true)); // 1

• I dette eksempel bruges unionstypen string | boolean til at angive, at argumentet enten er en streng eller en boolean.

String()

String()-funktionen konverterer tal eller boolean-værdier til strenge.

1function convertToString(value: number | boolean): string {
2    return String(value);
3}
4
5console.log(convertToString(123)); // "123"
6console.log(convertToString(false)); // "false"

• I dette eksempel oprettes en funktion, der accepterer en union af typen number | boolean og konverterer resultatet til en streng.

Array()

Array()-funktionen bruges til at oprette en ny array. Desuden tilbyder den mange nyttige metoder til at oprette underarrays fra eksisterende arrays eller udtrække specifikke elementer.

 1function createArray(): Array<number> {
 2    return Array(1, 2, 3, 4, 5); // 新しい配列を作成
 3}
 4
 5function getSubArray(array: Array<number>): Array<number> {
 6    return array.slice(1, 4); // サブ配列を作成
 7}
 8
 9const numbers = createArray();
10console.log(numbers); // [1, 2, 3, 4, 5]
11
12const subArray = getSubArray(numbers);
13console.log(subArray); // [2, 3, 4]

• Dette eksempel demonstrerer, hvordan man opretter en ny array ved hjælp af Array()-funktionen og opretter en underarray ved hjælp af slice()-metoden.

Array.isArray()

Array.isArray() afgør, om den givne værdi er en array.

1function checkArray(value: unknown): boolean {
2    return Array.isArray(value);
3}
4
5console.log(checkArray([1, 2, 3])); // true
6console.log(checkArray("Not an array")); // false

• Ved at bruge typen unknown accepterer vi enhver type, mens vi kontrollerer, om det er en array.

eval()

eval()-funktionen evaluerer en streng som et udtryk og returnerer resultatet. Det anbefales dog ikke at bruge den på grund af sikkerheds- og ydelsesrisici.

1function evaluateExpression(expression: string): any {
2    return eval(expression);
3}
4
5console.log(evaluateExpression("2 + 3")); // 5
6console.log(evaluateExpression("'Hello ' + 'World!'")); // "Hello World!"

• I dette eksempel evalueres et udtryk, der gives som en streng, ved hjælp af eval, og resultatet vises.

encodeURI()

encodeURI()-funktionen koder hele URL'en og undgår visse tegn.

1const uri = "https://example.com/page?name=John Doe&age=30";
2const encodedURI = encodeURI(uri);
3
4console.log(encodedURI); // "https://example.com/page?name=John%20Doe&age=30"

• Dette eksempel koder mellemrum til %20 for at generere en sikker URL.

decodeURI()

decodeURI()-funktionen dekoder en kodet URL tilbage til dets originale format.

1const encodedURI = "https://example.com/page?name=John%20Doe&age=30";
2const decodedURI = decodeURI(encodedURI);
3
4console.log(decodedURI); // "https://example.com/page?name=John Doe&age=30"

• Dette eksempel dekoder en kodet URL-streng tilbage til den originale URL.

setTimeout()

setTimeout()-funktionen udfører en angivet funktion efter den givne forsinkelsestid (i millisekunder).

1setTimeout(() => {
2    console.log("Executed after 2 seconds");
3}, 2000);

• Dette eksempel viser en besked efter 2 sekunder.

setInterval()

setInterval()-funktionen udfører gentagne gange en angivet funktion med det angivne interval (i millisekunder).

1let count = 0;
2const intervalId = setInterval(() => {
3    count++;
4    console.log(`Interval executed ${count} time(s)`);
5    if (count === 3) {
6        clearInterval(intervalId); // Stops the interval after 3 executions
7    }
8}, 1000);

• Dette eksempel viser en besked med et-sekunds intervaller og stopper efter at være blevet udført tre gange.

Konklusion

TypeScripts indbyggede funktioner muliggør mere sikker og effektiv kodning ved at tilføje typesikkerhed til standard JavaScript-funktioner. Disse funktioner forenkler daglige programmeringsopgaver og forbedrer kodens læsbarhed og vedligeholdelighed. Hver funktion bruges korrekt i henhold til dens formål, og ved at specificere typer kan den opdage fejl på forhånd, hvilket spiller en vigtig rolle i at forbedre pålideligheden af udviklingsprocessen.

Ved at bruge TypeScript kan udvikling drage fordel af statisk typning samtidig med at udnytte fleksibiliteten i JavaScript.

Du kan følge med i ovenstående artikel ved hjælp af Visual Studio Code på vores YouTube-kanal. Husk også at tjekke YouTube-kanalen.

YouTube Video