Fonctions intégrées dans TypeScript

Cet article explique les fonctions intégrées dans TypeScript.

YouTube Video

Fonctions intégrées dans TypeScript

Les fonctions intégrées dans TypeScript sont des fonctions pratiques fournies pour effectuer des opérations courantes de manière concise. Ce sont des fonctions JavaScript standard avec une sécurité de type supplémentaire, ce qui les rend particulièrement utiles lors du codage en TypeScript. Ici, nous expliquerons en détail certaines fonctions intégrées importantes, leur utilisation et la spécification des types.

Qu’est-ce que les fonctions intégrées ?

Les fonctions intégrées de TypeScript sont basées sur les fonctions JavaScript standard. L'application du système de types de TypeScript améliore la vérification des types et l'auto-complétion. Les principales fonctions comprennent les suivantes :.

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

Ces fonctions sont largement utilisées dans les projets TypeScript pour une conversion et une évaluation des données concises.

parseInt()

parseInt() est une fonction utilisée pour convertir une chaîne en un entier. Vous pouvez spécifier la base (comme binaire, décimal) comme deuxième argument. En TypeScript, vous pouvez spécifier le type comme suit :.

 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)

• Spécifiez que l'entrée est une chaîne avec value: string
• La valeur de retour est explicitement spécifiée comme un type number.

parseFloat()

parseFloat() est une fonction utilisée pour convertir une chaîne en un nombre à virgule flottante.

 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() peut analyser correctement les nombres comprenant des points décimaux.
• En spécifiant le type, vous pouvez recevoir un avertissement lors de la vérification des types si l'entrée n'est pas un nombre.

isNaN()

isNaN() est une fonction qui détermine si la valeur donnée est NaN (Not-a-Number). Un exemple d'utilisation en TypeScript est le suivant :.

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

• Le type unknown est un type générique qui peut accepter n'importe quel type.
• Convertissez en un nombre en utilisant la fonction Number() et vérifiez si le résultat est NaN.

isFinite()

isFinite() détermine si une valeur est finie.

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

• Cette fonction utilise également Number() pour convertir la valeur en un nombre avant de déterminer.

Number()

La fonction Number() convertit les chaînes ou les valeurs booléennes en nombres.

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

• Dans cet exemple, un type union string | boolean est utilisé pour spécifier que l'argument est soit une chaîne de caractères, soit un booléen.

String()

La fonction String() convertit les nombres ou les valeurs booléennes en chaînes de caractères.

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

• Dans cet exemple, une fonction est créée qui accepte une union de type number | boolean et convertit le résultat en une chaîne de caractères.

Array()

La fonction Array() est utilisée pour créer un nouveau tableau. De plus, elle offre de nombreuses méthodes utiles pour créer des sous-tableaux à partir de tableaux existants ou extraire des éléments spécifiques.

 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]

• Cet exemple montre comment créer un nouveau tableau à l'aide de la fonction Array() et créer un sous-tableau à l'aide de la méthode slice().

Array.isArray()

Array.isArray() détermine si la valeur donnée est un tableau.

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

• En utilisant le type unknown, nous acceptons n'importe quel type tout en vérifiant s'il s'agit d'un tableau.

eval()

La fonction eval() évalue une chaîne comme une expression et renvoie le résultat. Cependant, il n'est pas recommandé de l'utiliser en raison des risques de sécurité et de performance.

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

• Dans cet exemple, une expression fournie en tant que chaîne est évaluée avec eval, et le résultat est affiché.

encodeURI()

La fonction encodeURI() encode l'ensemble de l'URL et échappe certains caractères.

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"

• Cet exemple encode les espaces en %20 pour générer une URL sécurisée.

decodeURI()

La fonction decodeURI() décode une URL encodée pour revenir à son format d'origine.

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"

• Cet exemple décode une chaîne d'URL encodée pour revenir à l'URL d'origine.

setTimeout()

La fonction setTimeout() exécute une fonction spécifiée après le délai donné (en millisecondes).

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

• Cet exemple affiche un message après 2 secondes.

setInterval()

La fonction setInterval() exécute de manière répétée une fonction spécifiée à l'intervalle désigné (en millisecondes).

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

• Cet exemple affiche un message à des intervalles d'une seconde et s'arrête après avoir été exécuté trois fois.

Conclusion

Les fonctions intégrées de TypeScript permettent un codage plus sûr et plus efficace en ajoutant une sécurité typée aux fonctions standard de JavaScript. Ces fonctions simplifient les tâches de programmation quotidiennes et améliorent la lisibilité et la maintenabilité du code. Chaque fonction est utilisée correctement selon son objectif, et en spécifiant les types, elle peut détecter les erreurs à l'avance, jouant un rôle important dans l'amélioration de la fiabilité du processus de développement.

En utilisant TypeScript, le développement peut tirer parti du typage statique tout en exploitant la flexibilité de JavaScript.

Vous pouvez suivre l'article ci-dessus avec Visual Studio Code sur notre chaîne YouTube. Veuillez également consulter la chaîne YouTube.

YouTube Video