Inbyggda funktioner i TypeScript

Den här artikeln förklarar inbyggda funktioner i TypeScript.

YouTube Video

Inbyggda funktioner i TypeScript

Inbyggda funktioner i TypeScript är praktiska funktioner som tillhandahålls för att utföra vardagliga operationer på ett koncist sätt. Dessa är standardfunktioner i JavaScript med extra typer som säkerhet, vilket gör dem särskilt användbara vid kodning i TypeScript. Här kommer vi att förklara i detalj några viktiga inbyggda funktioner, deras användning och typspecifikation.

Vad är inbyggda funktioner?

TypeScripts inbyggda funktioner baseras på standardfunktioner i JavaScript. Användning av TypeScripts typsystem förbättrar typkontroll och autokomplettering. De viktigaste funktionerna inkluderar följande:.

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

Dessa funktioner används ofta i TypeScript-projekt för koncis datakonvertering och utvärdering.

parseInt()

parseInt() är en funktion som används för att konvertera en sträng till ett heltal. Du kan ange basen (till exempel binär, decimal) som det andra argumentet. I TypeScript kan du ange typen enligt följande:.

 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)

• Ange att indata är en sträng med value: string
• Returvärdet anges uttryckligen som typen number.

parseFloat()

parseFloat() är en funktion som används för att konvertera en sträng till ett flyttal.

 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 tolka tal inklusive decimalpunkter.
• Genom att ange typen kan du få en varning under typkontroll om indata inte är ett tal.

isNaN()

isNaN() är en funktion som avgör om det givna värdet är NaN (Not-a-Number). Ett exempel på användning i TypeScript är följande:.

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

• Typen unknown är en generell typ som kan acceptera vilken typ som helst.
• Konvertera till ett tal med funktionen Number() och kontrollera om resultatet är NaN.

isFinite()

isFinite() avgör om ett värde är ändligt.

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

• Denna funktion använder också Number() för att konvertera värdet till ett tal innan det avgörs.

Number()

Funktionen Number() konverterar strängar eller booleska värden till tal.

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

• I det här exemplet används en unionstyp string | boolean för att ange att argumentet antingen är en sträng eller en boolean.

String()

String()-funktionen konverterar siffror eller booleanvärden till strängar.

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

• I det här exemplet skapas en funktion som accepterar en union av typen number | boolean och konverterar resultatet till en sträng.

Array()

Array()-funktionen används för att skapa en ny array. Dessutom erbjuder den många användbara metoder för att skapa under-arrayer från befintliga arrayer eller extrahera specifika element.

 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]

• Det här exemplet visar hur man skapar en ny array med funktionen Array() och skapar en under-array med metoden slice().

Array.isArray()

Array.isArray() avgör om det angivna värdet är 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

• Genom att använda typen unknown accepterar vi vilken typ som helst samtidigt som vi kontrollerar om det är en array.

eval()

eval()-funktionen utvärderar en sträng som ett uttryck och returnerar resultatet. Det är dock inte rekommenderat att använda den på grund av säkerhets- och prestandarisker.

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 det här exemplet utvärderas ett uttryck som tillhandahålls som en sträng med eval, och resultatet skrivs ut.

encodeURI()

encodeURI()-funktionen kodar hela URL:en och undviker vissa tecken.

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"

• I det här exemplet kodas mellanslag till %20 för att skapa en säker URL.

decodeURI()

decodeURI()-funktionen avkodar en kodad URL tillbaka till dess ursprungliga 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"

• Det här exemplet avkodar en kodad URL-sträng tillbaka till den ursprungliga URL:en.

setTimeout()

setTimeout()-funktionen kör en angiven funktion efter den angivna fördröjningstiden (i millisekunder).

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

• I det här exemplet visas ett meddelande efter 2 sekunder.

setInterval()

setInterval()-funktionen kör upprepade gånger en angiven funktion med det angivna intervallet (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);

• Detta exempel visar ett meddelande med en sekunds intervall och slutar efter att ha körts tre gånger.

Slutsats

TypeScripts inbyggda funktioner möjliggör säkrare och mer effektiv kodning genom att lägga till typsäkerhet till standard-JavaScript-funktioner. Dessa funktioner förenklar vardagliga programmeringsuppgifter och förbättrar kodläsbarhet och underhållbarhet. Varje funktion används korrekt enligt dess syfte, och genom att specificera typer kan den upptäcka fel i förväg, vilket spelar en viktig roll för att förbättra tillförlitligheten i utvecklingsprocessen.

Genom att använda TypeScript kan utvecklingen dra nytta av statisk typning samtidigt som flexibiliteten i JavaScript används.

Du kan följa med i artikeln ovan med hjälp av Visual Studio Code på vår YouTube-kanal. Vänligen kolla även in YouTube-kanalen.

YouTube Video