Funzioni incorporate in TypeScript

Questo articolo spiega le funzioni incorporate in TypeScript.

YouTube Video

Funzioni incorporate in TypeScript

Le funzioni incorporate in TypeScript sono funzioni utili fornite per eseguire operazioni quotidiane in modo conciso. Queste sono funzioni standard di JavaScript con una maggiore sicurezza dei tipi, rendendole particolarmente utili durante la programmazione in TypeScript. Qui spiegheremo in dettaglio alcune importanti funzioni incorporate, il loro utilizzo e la specifica dei tipi.

Cosa sono le funzioni incorporate?

Le funzioni incorporate di TypeScript si basano sulle funzioni standard di JavaScript. Applicando il sistema di tipi di TypeScript si migliorano il controllo dei tipi e l'autocompletamento. Le funzioni principali includono le seguenti:.

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

Queste funzioni sono ampiamente utilizzate nei progetti TypeScript per la conversione e la valutazione concisa dei dati.

parseInt()

parseInt() è una funzione utilizzata per convertire una stringa in un numero intero. È possibile specificare la base (come binario o decimale) come secondo argomento. In TypeScript, è possibile specificare il tipo come segue:.

 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)

• Specificare che l'input è una stringa con value: string
• Il valore restituito è specificato esplicitamente come tipo number.

parseFloat()

parseFloat() è una funzione utilizzata per convertire una stringa in un numero in virgola mobile.

 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() può analizzare correttamente i numeri inclusi i punti decimali.
• Specificando il tipo, è possibile ricevere un avviso durante il controllo dei tipi se l'input non è un numero.

isNaN()

isNaN() è una funzione che determina se il valore dato è NaN (Not-a-Number). Un esempio di utilizzo in TypeScript è il seguente:.

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

• Il tipo unknown è un tipo generico che può accettare qualsiasi tipo.
• Convertire in un numero utilizzando la funzione Number() e verificare se il risultato è NaN.

isFinite()

isFinite() determina se un valore è finito.

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

• Questa funzione utilizza anche Number() per convertire il valore in un numero prima di effettuare la determinazione.

Number()

La funzione Number() converte le stringhe o i valori booleani in numeri.

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

• In questo esempio, un tipo unione string | boolean viene utilizzato per specificare che l'argomento è o una stringa o un valore booleano.

String()

La funzione String() converte numeri o valori booleani in stringhe.

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

• In questo esempio, viene creata una funzione che accetta un'unione di tipo number | boolean e converte il risultato in una stringa.

Array()

La funzione Array() viene utilizzata per creare un nuovo array. Inoltre, fornisce molti metodi utili per creare sottoarray da array esistenti o per estrarre elementi specifici.

 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]

• Questo esempio dimostra come creare un nuovo array utilizzando la funzione Array() e come creare un sottoarray utilizzando il metodo slice().

Array.isArray()

Array.isArray() determina se il valore fornito è un 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

• Utilizzando il tipo unknown, accettiamo qualsiasi tipo verificando se è un array.

eval()

La funzione eval() valuta una stringa come un'espressione e restituisce il risultato. Tuttavia, non è raccomandato usarla a causa di rischi di sicurezza e prestazioni.

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

• In questo esempio, un'espressione fornita come stringa viene valutata utilizzando eval e il risultato è mostrato.

encodeURI()

La funzione encodeURI() codifica l'intero URL e esegue l'escape di determinati caratteri.

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"

• Questo esempio codifica gli spazi in %20 per generare un URL sicuro.

decodeURI()

La funzione decodeURI() decodifica un URL codificato riportandolo al suo formato originale.

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"

• Questo esempio decodifica una stringa URL codificata riportandola all'URL originale.

setTimeout()

La funzione setTimeout() esegue una funzione specifica dopo il tempo di ritardo fornito (in millisecondi).

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

• Questo esempio mostra un messaggio dopo 2 secondi.

setInterval()

La funzione setInterval() esegue ripetutamente una funzione specificata all'intervallo stabilito (in millisecondi).

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);

• Questo esempio visualizza un messaggio a intervalli di un secondo e si ferma dopo essere stato eseguito tre volte.

Conclusione

Le funzioni integrate di TypeScript consentono una programmazione più sicura ed efficiente aggiungendo la sicurezza dei tipi alle funzioni standard di JavaScript. Queste funzioni semplificano le attività di programmazione quotidiane e migliorano la leggibilità e la manutenibilità del codice. Ogni funzione viene utilizzata correttamente in base al suo scopo e, specificando i tipi, è possibile rilevare errori in anticipo, svolgendo un ruolo importante nel miglioramento dell'affidabilità del processo di sviluppo.

Utilizzando TypeScript, lo sviluppo può beneficiare del tipaggio statico sfruttando al contempo la flessibilità di JavaScript.

Puoi seguire l'articolo sopra utilizzando Visual Studio Code sul nostro canale YouTube. Controlla anche il nostro canale YouTube.

YouTube Video