Fonctions intégrées en JavaScript

Cet article explique les fonctions intégrées en JavaScript.

YouTube Video

Fonctions intégrées en JavaScript

JavaScript propose une variété de fonctions intégrées, qui sont des outils puissants pour créer des programmes de manière efficace. Ici, nous expliquerons en détail les fonctions intégrées typiques de JavaScript. En apprenant les rôles, les usages et les précautions de chaque fonction, vous pourrez utiliser JavaScript de manière plus efficace.

Quelles sont les fonctions intégrées ?

Les fonctions intégrées sont des fonctions fournies par défaut dans JavaScript. Ces fonctions sont conçues pour exécuter des tâches spécifiques de manière concise. Les programmeurs n'ont pas besoin de les implémenter indépendamment, ce qui améliore la lisibilité et la maintenabilité du code.

Fonctions intégrées représentatives

parseInt()

1// Convert string to integer
2console.log(parseInt("42"));      // Output: 42
3console.log(parseInt("42px"));    // Output: 42
4console.log(parseInt("0xF", 16)); // Output: 15
5console.log(parseInt("0xF"));     // Output: 15
6console.log(parseInt("px42"));    // Output: NaN

• parseInt() est une fonction qui analyse une chaîne et la convertit en un entier. Si le début de la chaîne contient un nombre, cette partie est renvoyée en tant qu'entier. Un radix (base) optionnel peut également être spécifié.

• Si le début de la chaîne ne contient pas de nombre, il renvoie NaN (Not-a-Number). De plus, si aucun radix n'est spécifié, il est par défaut en décimal, mais si la chaîne commence par "0x", elle est interprétée comme hexadécimale.

parseFloat()

1// Convert string to float
2console.log(parseFloat("3.14"));      // Output: 3.14
3console.log(parseFloat("3.14abc"));   // Output: 3.14
4console.log(parseFloat("42"));        // Output: 42

• parseFloat() analyse une chaîne et la convertit en un nombre à virgule flottante. Elle est utilisée pour traiter des nombres comportant un point décimal.

• Comme parseInt(), si le début de la chaîne n'est pas un nombre, elle renvoie NaN. Elle est caractérisée par l'analyse correcte non seulement de la partie entière, mais aussi de la partie décimale.

isNaN()

1console.log(isNaN(NaN));         // Output: true
2console.log(isNaN(42));          // Output: false
3console.log(isNaN("hello"));     // Output: true

• isNaN() détermine si une valeur donnée est NaN. NaN (Not-a-Number) représente une valeur non valide en tant que nombre.

• isNaN() est également valide pour des types de données autres que les nombres et, par exemple, renvoie true si une chaîne ne peut pas être convertie en nombre.

Number()

1console.log(Number("42"));        // Output: 42
2console.log(Number("3.14"));      // Output: 3.14
3console.log(Number("0xff"));      // Output: 255
4console.log(Number("abc"));       // Output: NaN

• Number() est une fonction qui convertit des chaînes ou d'autres types de données en un nombre. Il renvoie NaN si une chaîne non numérique est donnée.

• Contrairement à parseInt() ou parseFloat(), Number() considère cela comme une conversion invalide et renvoie NaN si la chaîne contient des caractères non numériques.

String()

1console.log(String(42));           // Output: "42"
2console.log(String(3.14));         // Output: "3.14"
3console.log(String(true));         // Output: "true"
4console.log(String(null));         // Output: "null"
5console.log(String(undefined));    // Output: "undefined"

• String() est une fonction qui convertit les nombres et d'autres types de données en chaînes de caractères. String(42) renvoie la chaîne "42".
• Si la valeur à convertir est null ou undefined, elle renvoie respectivement les chaînes "null" ou "undefined".
• Elle est utile pour gérer divers types de données, comme les nombres, les booléens ou les objets, en les convertissant en chaînes de caractères.

Array

1const arr = Array(3);
2console.log(arr); // Output: [ <3 empty items> ]
3
4const arr2 = Array(1, 2, 3);
5console.log(arr2); // Output: [1, 2, 3]

• Array est un constructeur utilisé pour créer de nouveaux tableaux.
• S'il y a un seul argument, celui-ci est traité comme la longueur du tableau, et un tableau vide est créé.
• S'il y a plusieurs arguments, un tableau contenant ces valeurs comme éléments est créé.

Array.isArray()

1console.log(Array.isArray([1, 2, 3])); // Output: true
2console.log(Array.isArray("not an array")); // Output: false

• Array.isArray() est une méthode qui détermine si l'argument est un tableau.
• Elle renvoie true si l'argument est un tableau, et false sinon.

isFinite()

1console.log(isFinite(42));         // Output: true
2console.log(isFinite(Infinity));   // Output: false
3console.log(isFinite(NaN));        // Output: false

• isFinite() détermine si une valeur donnée est finie. Renvoie true pour les nombres finis et false dans le cas contraire (comme pour l'infini ou NaN).

• En JavaScript, Infinity et -Infinity représentent l'infini et sont du type nombre, mais isFinite() considère l'infini comme une valeur invalide.

eval()

1let expression = "2 + 2";
2console.log(eval(expression));    // Output: 4
3
4console.log(eval("var x = 10; x * 2"));  // Output: 20

• eval() est une fonction qui évalue et exécute du code JavaScript donné sous forme de chaîne. Vous pouvez exécuter dynamiquement du code JavaScript.

• eval() est très puissant, mais il présente un risque de sécurité, il convient donc de l'éviter dans le développement réel. Exécuter du code fourni de manière externe avec eval() peut entraîner des comportements inattendus et des vulnérabilités de sécurité.

encodeURI() / decodeURI()

1let url = "https://example.com/?name=John Doe&age=25";
2let encodedUrl = encodeURI(url);
3console.log(encodedUrl);
4// Output: https://example.com/?name=John%20Doe&age=25
5
6let decodedUrl = decodeURI(encodedUrl);
7console.log(decodedUrl);
8// Output: https://example.com/?name=John Doe&age=25

• encodeURI() est une fonction utilisée pour encoder (convertir) des caractères qui ne peuvent pas être utilisés dans une URL. D'autre part, decodeURI() décode une URL encodée pour retrouver sa forme originale.

• L'encodage est particulièrement important lors de la gestion de caractères spéciaux. Par exemple, des caractères comme les espaces ou & doivent être encodés pour être correctement inclus dans une URL, ils doivent donc être traités de manière appropriée en utilisant encodeURI().

setTimeout() / setInterval()

 1// Execute a function after 2 seconds
 2setTimeout(() => {
 3    console.log("This runs after 2 seconds");
 4}, 2000);
 5
 6// Execute a function every 1 second
 7let intervalId = setInterval(() => {
 8    console.log("This runs every 1 second");
 9}, 1000);
10
11// Stop the interval after 5 seconds
12setTimeout(() => {
13    clearInterval(intervalId);
14}, 5000);

• setTimeout() est une fonction de minuterie utilisée pour exécuter une fonction une seule fois après un temps spécifié. setInterval() exécute une fonction de manière répétée à des intervalles spécifiés.

• setTimeout() et setInterval() s'exécutent de manière asynchrone, en appelant la fonction après l'expiration du temps spécifié. Il est également possible d'annuler les exécutions en utilisant clearTimeout() ou clearInterval().

Résumé

Utiliser les fonctions intégrées de JavaScript vous permet d'écrire des programmes plus simples et plus efficaces. Les fonctions présentées ici sont basiques et utiles dans diverses situations. Assurez-vous d'écrire du code réel et de vérifier son comportement pour approfondir votre compréhension.

Apprenez des traitements plus complexes et des utilisations avancées des fonctions pour améliorer davantage vos compétences en 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