Les Fonctions intégrées dans JavaScript

Laisser un commentaire / cours javascript / Par

les Fonctions Intégrées à JavaScript : (Built-in Functions)

les fonctions intégrées javascript image

 

JavaScript, en tant que langage de programmation offre une quantité impressionnante de fonctions intégrées (ou « built-in functions ») qui facilitent grandement le développement.

Ces fonctions sont pré-définies et disponibles directement dans le langage, sans nécessiter de déclaration préalable. Elles permettent de réaliser des tâches courantes de manière simple et efficace.

Les Fonctions Intégrées de Base en Javascript

 
 

Les Méthodes sur les Types Primitifs

 

JavaScript fournit plusieurs fonctions intégrées pour manipuler les types primitifs tels que les chaînes de caractères, les nombres et les booléens. Par exemple :

  • String.prototype.toUpperCase() : Convertit tous les caractères d’une chaîne en majuscules.

 

let texte = "salut";
console.log(texte.toUpperCase()); // "SALUT"
 
 
 
  • Number.prototype.toFixed() : Formate un nombre en une chaîne avec un nombre fixe de décimales.
 
 

let pi = 3.14159;
console.log(pi.toFixed(2)); // "3.14"
 
 

Les Méthodes sur les Objets

 

Les objets en JavaScript disposent également de méthodes intégrées pour faciliter leur manipulation :

  • Object.keys() : Retourne un tableau contenant les noms des propriétés d’un objet.

 


let personne = { nom: "Mathilda", age: 25 };
console.log(Object.keys(personne)); // ["nom", "age"]
 
 
  • Object.values() : Retourne un tableau contenant les valeurs des propriétés d’un objet.
 
 

let personne = { nom: "Mathilda", age: 25 };
console.log(Object.values(personne)); // ["Mathilda", 25]
 
 
 

Les Fonctions Intégrées pour les Tableaux

 
 

Les tableaux en JavaScript sont dotés de méthodes puissantes qui facilitent le traitement des données :

  • Array.prototype.map() : Applique une fonction à chaque élément d’un tableau et retourne un nouveau tableau avec les résultats.

 

 


let nombres = [1, 2, 3];
let doubles = nombres.map(n => n * 2);
console.log(doubles); // [2, 4, 6]
 
 
  • Array.prototype.filter() : Crée un nouveau tableau avec tous les éléments qui passent un test.
 

 


let chiffres = [1, 2, 3, 4, 5];
let pairs = chiffres.filter(n => n % 2 === 0);
console.log(pairs); // [2, 4]
 
 
 

Les Fonctions Intégrées pour la Gestion des Dates

 

Pour manipuler les dates, JavaScript propose des fonctions pratiques :

  • Date.prototype.getDay() : Retourne le jour de la semaine (de 0 à 6) pour une date donnée.

 

 

let dateDuJour = new Date();
console.log(dateDuJour.getDay()); // Par exemple, 3 pour mercredi
 
 
  •  Date.prototype.toLocaleDateString() : Retourne une chaîne de caractères représentant la date au format local.
 
 

console.log(dateDuJour.toLocaleDateString()); // "01/08/2024" (format dépend de la localité)
 
 
 

Maintenant Pourquoi connaître les Fonctions Intégrées ?

Les fonctions intégrées en JavaScript sont très importantes à connaître pour un développeur Javascript.

Elles permettent non seulement de simplifier vos tâches répétitives mais aussi de garantir une meilleure approche et une bonne connaissance des fonctions utilisés couramment par d’autre développeurs et de lisibilité de votre code.

Maîtrisez ces fonctions, vous gagnerez en productivité et en adaptabilité dans tout types de projets.

 

Voici pour vous un bon panel et quelques autres exemples de fonctions intégrées en JavaScript qui sont fréquemment utilisées pour diverses tâches :

 

Les Fonctions Mathématiques

 

JavaScript offre plusieurs fonctions mathématiques utiles dans l’objet Math, qui est accessible directement sans besoin d’instanciation :

  • Math.max() : Retourne le plus grand nombre parmi les arguments passés.

 


let maximum = Math.max(10, 20, 30);
console.log(maximum); // 30
 
 
  •  Math.min() : Retourne le plus petit nombre parmi les arguments passés.
 

 

 
let minimum = Math.min(10, 20, 30);
console.log(minimum); // 10
 
 
  •  Math.random() : Retourne un nombre flottant pseudo-aléatoire compris entre 0 (inclus) et 1 (exclus).
 
 
 
let aleatoire = Math.random();
console.log(aleatoire); // Par exemple, 0.4538765423435
 
 
  •  Math.floor() : Arrondit un nombre vers le bas à l’entier le plus proche.
 
 
 
let entierInferieur = Math.floor(4.7);
console.log(entierInferieur); // 4
 
 
 
 

Les Fonctions pour Manipuler les Chaînes de Caractères

 
 

En plus des fonctions mentionnées précédemment, JavaScript propose d’autres méthodes pour travailler avec les chaînes de caractères :

  • String.prototype.includes() : Vérifie si une chaîne contient une sous-chaîne donnée.

 

 
let phrase = "Bonjour le monde";
console.log(phrase.includes("monde")); // true
 
 
  •  String.prototype.replace() : Remplace une partie d’une chaîne par une autre.
 

 

 
let salutation = "Salut, Développeur Pro";
let nouvelleSalutation = salutation.replace("Pro", "JS");
console.log(nouvelleSalutation); // "Salut, Développeur JS"
 
 
  •  String.prototype.split() : Divise une chaîne en un tableau de sous-chaînes selon un séparateur spécifié.

 

 
let chaine = "Développeur,FrontEnd,Professionnel";
let tableau = chaine.split(",");
console.log(tableau); // ["Développeur", "FrontEnd", "Professionnel"]
 
 
  • String.prototype.charAt() : Retourne le caractère à l’indice spécifié dans une chaîne de caractères.

 

 
let texte = "JavaScript";
console.log(texte.charAt(2)); // "v"
 
 
  • String.prototype.charCodeAt() : Retourne le code UTF-16 du caractère à l’indice spécifié dans une chaîne.

 

 
let texte = "JavaScript";
console.log(texte.charCodeAt(2)); // 118 (code pour "v")
 
 
  • String.prototype.concat() : Combine deux ou plusieurs chaînes de caractères et retourne une nouvelle chaîne (existe aussi pour les tableaux arrays).

 

 
let texte1 = "Java";
let texte2 = "Script";
let resultat = texte1.concat(texte2);
console.log(resultat); // "JavaScript"
 
 
  • String.prototype.trim() : Supprime les espaces blancs au début et à la fin d’une chaîne de caractères.

 

 
let texte = "   Bonjour   ";
console.log(texte.trim()); // "Bonjour"
 
 
  • String.prototype.substring() : Retourne une sous-chaîne d’une chaîne en fonction des indices de début et de fin, permet de retrouver quelque chose et de l’isoler dans une chaîne.

 

 
let texte = "JavaScript";
let sousChaine = texte.substring(4, 10);
console.log(sousChaine); // "Script"
 
 
  • String.prototype.substr() : Retourne une partie de la chaîne en fonction de l’indice de début et du nombre de caractères à extraire. Cependant, cette méthode est dépréciée au profit de substring().

 

 
let texte = "JavaScript";
let sousChaine = texte.substr(4, 6);
console.log(sousChaine); // "Script"
 
 
  • String.prototype.split() : Divise une chaîne de caractères en un tableau de sous-chaînes en fonction d’un séparateur spécifié.

 

 
let texte = "Salut tout le monde";
let mots = texte.split(" ");
console.log(mots); // ["Salut", "tout", "le", "monde"]
 
 
 
 
 

Les Fonctions pour Manipuler les Tableaux

 
 
 

Voici d’autres méthodes pratiques pour les tableaux :

 

  • Array.prototype.reduce() : Applique une fonction à un accumulateur et à chaque valeur d’un tableau (de gauche à droite) pour le réduire à une seule valeur.

 

 
let nombres = [1, 2, 3, 4];
let somme = nombres.reduce((acc, val) => acc + val, 0);
console.log(somme); // 10
 
 
  •  Array.prototype.find() : Retourne la première valeur d’un tableau qui satisfait une condition donnée.
 
 
 
let personnes = [{nom: "Sandra", age: 35}, {nom: "Karim", age: 30}];
let personneTrouvee = personnes.find(personne => personne.age === 30);
console.log(personneTrouvee); // {nom: "Karim", age: 30}
 
 
  • Array.prototype.some() : Vérifie si au moins un élément d’un tableau satisfait une condition donnée.
 

 

 
let nombres = [1, 2, 3, 4];
let auMoinsUnPair = nombres.some(n => n % 2 === 0);
console.log(auMoinsUnPair); // true
 
 
  • Array.prototype.splice() : Modifie le contenu d’un tableau en supprimant, remplaçant ou ajoutant des éléments. C’est une fonction très utile et flexible.

 

 
let fruits = ["pomme", "banane", "cerise"];
fruits.splice(1, 1, "orange"); // Remplace "banane" par "orange"
console.log(fruits); // ["pomme", "orange", "cerise"]
 
 
  • Array.prototype.slice() : Retourne une copie superficielle d’une portion d’un tableau, en sélectionnant les éléments à partir d’un indice de début jusqu’à un indice de fin (non inclus).

 

 
let fruits = ["pomme", "banane", "cerise", "orange"];
let copie = fruits.slice(1, 3); // Retourne ["banane", "cerise"]
console.log(copie);
 
 
  • Array.prototype.concat() : Combine deux ou plusieurs tableaux et retourne un nouveau tableau (existe aussi pour les string chaînes de caractères).

 

 
let fruits1 = ["pomme", "banane"];
let fruits2 = ["cerise", "orange"];
let tousLesFruits = fruits1.concat(fruits2);
console.log(tousLesFruits); // ["pomme", "banane", "cerise", "orange"]
 
 
  • Array.prototype.indexOf() : Retourne le premier indice où un élément donné peut être trouvé dans le tableau, ou -1 si l’élément n’est pas présent.

 

 
let fruits = ["pomme", "banane", "cerise"];
let index = fruits.indexOf("banane");
console.log(index); // 1
 
 
  • Array.prototype.join() : Réunit tous les éléments d’un tableau en une seule chaîne, en utilisant un séparateur spécifié.

 

 
let fruits = ["pomme", "banane", "cerise"];
let chaine = fruits.join(", ");
console.log(chaine); // "pomme, banane, cerise"
 
 
  • Array.prototype.reverse() : Inverse l’ordre des éléments dans un tableau.

 

 
let fruits = ["pomme", "banane", "cerise"];
fruits.reverse();
console.log(fruits); // ["cerise", "banane", "pomme"]
 
 
  • Array.prototype.sort() : Trie les éléments d’un tableau selon une fonction de comparaison facultative.

 

 
let chiffres = [3, 1, 4, 1, 5];
chiffres.sort((a, b) => a - b);
console.log(chiffres); // [1, 1, 3, 4, 5]
 
 
 
 

 

Les Fonctions de Conversion

 
 

JavaScript propose également des fonctions pour convertir des valeurs d’un type à un autre :

 

  • parseInt() : Convertit une chaîne de caractères en un entier.

 

 
let entier = parseInt("123");
console.log(entier); // 123
 
 
  •  parseFloat() : Convertit une chaîne de caractères en un nombre flottant.
 
 
 
let flottant = parseFloat("3.14");
console.log(flottant); // 3.14
 
 
  •  Number() : Convertit une chaîne ou un autre type de donnée en un nombre.

 

 
let nombre = Number("123.45");
console.log(nombre); // 123.45
 
 

 

Les Fonctions pour Manipuler les Objets

 
 

Enfin, voici des fonctions intégrées pour manipuler les objets :

  • Object.assign() : Copie les valeurs des propriétés de tous les objets sources dans un objet cible.

 
 
 
let cible = { a: 1 };
let source = { b: 2, c: 3 };
Object.assign(cible, source);
console.log(cible); // { a: 1, b: 2, c: 3 }
 
 
  • Object.freeze() : Gèle un objet, empêchant toute modification de ses propriétés.
 
 
 
let objet = { nom: "Alban" };
Object.freeze(objet);
objet.nom = "Michael"; // Ignoré, car l'objet est gelé
console.log(objet.nom); // "Alban"
 
 
  • Object.create() : Crée un nouvel objet en utilisant un autre objet comme prototype.
 
 
 
let LePrototypeObjet = {type: "animal"};
let ObjetChien = Object.create(LePrototypeObjet);
ObjetChien.nom = "Rex";
console.log(ObjetChien.type); // "animal"
console.log(ObjetChien.nom); // "Rex"
 
 
  • Object.entries() : Retourne un tableau de paires clé-valeur pour chaque propriété énumérable propre d’un objet.
 
 
 
let objet = {a: 1, b: 2, c: 3};
console.log(Object.entries(objet)); // [["a", 1], ["b", 2], ["c", 3]]
 
 
  • Object.fromEntries() : Convertit un tableau de paires clé-valeur en un objet.
 
 
 
let paires = [["a", 1], ["b", 2], ["c", 3]];
let objet = Object.fromEntries(paires);
console.log(objet); // {a: 1, b: 2, c: 3}
 
 
 
 
 

Les Fonctions de Manipulation de Types

 
 

Ces fonctions permettent de vérifier et de manipuler les types de données en JavaScript :

  • typeof : Renvoie une chaîne indiquant le type d’une variable ou d’une expression.

 

 

 
let nom = "Cornelius";
console.log(typeof nom); // "string"
 
 
  • instanceof : Vérifie si un objet est une instance d’une classe ou d’une fonction constructeur. Voir chapitre des classes et des instances.
 
 
 
let date = new Date();
console.log(date instanceof Date); // true
 
 
  • Array.isArray() : Détermine si une valeur est un tableau.
 
 
 
let tableau = [1, 2, 3];
console.log(Array.isArray(tableau)); // true
 
 
 
 

Les Fonctions d’Espace Temps et d’Evaluations

 
 

Ces fonctions facilitent l’évaluation du code javascript, la gestion et l’interaction avec le contexte d’exécution, les espaces temporelles liés à une attente d’exécution après une action ou pas:

  • eval() : Évalue du code JavaScript contenu dans une chaîne de caractères.

 

 
let code = "2 + 2";
console.log(eval(code)); // 4
 
 Note : eval() doit être utilisé avec précaution en raison des risques de sécurité.

 

  • setTimeout() : Exécute une fonction après un délai spécifié.

 

 
setTimeout(() => {
  console.log("le code s affiche après 2 secondes ou le délai spécifié ");
}, 2000);
 
 
  •  setInterval() et clearInterval() : setInterval()  Exécute une fonction de manière répétée avec un délai fixe entre chaque exécution et clearInterval() annule l’action répéter par setInterval() fonction.
 
 
let compteur = 0;
let intervalle = setInterval(() => {
  compteur++;
  console.log("Compteur : " + compteur);
  if (compteur >= 5) clearInterval(intervalle);
}, 1000);
 
 

 

Les Fonctions pour Travailler avec JSON

 
 
 

JavaScript dispose de fonctions intégrées pour manipuler les données JSON (JavaScript Object Notation) :

 

  • JSON.stringify() : Convertit un objet, un tableau, une string etc…  n’importe quel valeur JavaScript en une chaîne JSON.

 
 
 
let objet = { nom: "DevPro", age: 29 };
let json = JSON.stringify(objet);
console.log(json); // '{"nom":"DevPro","age":29}'
 
 
  •  JSON.parse() : Convertit une chaîne JSON en une valeur JavaScript (string, objet, number, tableau).

 

 
let json = '["Devenir","Développeur","Professionnel"]';
let tableau = JSON.parse(json);
console.log(tableau[1]); // "Développeur"
 
 
 

Les Fonctions pour Travailler avec les Promesses

 
 

Avec l’introduction des Promises voir le chapitre dédié, JavaScript propose des fonctions intégrées pour gérer le code asynchrone de manière plus lisible :

 

  • Promise.resolve() : Retourne une promesse qui est résolue avec la valeur donnée.

 

 
let promesse = Promise.resolve("Succès");
promesse.then(valeur => console.log(valeur)); // "Succès"
 
 
  • Promise.reject() : Retourne une promesse qui est rejetée avec la raison donnée.

 

 
let promesse = Promise.reject("Erreur");
promesse.catch(raison => console.log(raison)); // "Erreur"
 
 
  • Promise.all() : Prend un tableau de promesses et retourne une promesse unique qui se résout lorsque toutes les promesses se sont résolues.
 
 
 
let promesse1 = Promise.resolve(3);
let promesse2 = Promise.resolve(42);
let promesse3 = new Promise((resolve, reject) => setTimeout(resolve, 100, "foo"));

Promise.all([promesse1, promesse2, promesse3]).then(valeurs => {
  console.log(valeurs); // [3, 42, "foo"]
});
 
 
 
 

Fonctions d’Encodage et de Décodage

 
 

  • encodeURIComponent() : Encode une chaîne de caractères pour l’utiliser dans une URI.

 

 

 
let uri = "nom=Jean & ville=Paris";
console.log(encodeURIComponent(uri)); // "nom%3DJean%20%26%20ville%3DParis"
 
 
  •  decodeURIComponent() : Décodage inverse d’une chaîne encodée avec encodeURIComponent().
 
 
 
let uriEncode = "nom%3DJean%20%26%20ville%3DParis";
console.log(decodeURIComponent(uriEncode)); // "nom=Jean & ville=Paris"
 
 
 Ces autres fonctions utilitaires de décodages et d’encodages aussi pratiques pour divers cas d’usage :
 
 

  • encodeURI() et decodeURI() : Encodent et décodent les URI en remplaçant les caractères spéciaux par des séquences échappées.

 

 
let uri = "https://example.com/?nom=Jean & ville=Paris";
let uriEncode = encodeURI(uri);
console.log(uriEncode); // "https://example.com/?nom=Jean%20&%20ville=Paris"
console.log(decodeURI(uriEncode)); // "https://example.com/?nom=Jean & ville=Paris"
 
 
  •  escape() et unescape() : Encodent et décodent les chaînes de caractères.

 

 
let texte = "Salut à tous !";
let texteEchappe = escape(texte);
console.log(texteEchappe); // "Salut%20%E0%20tous%20%21"
console.log(unescape(texteEchappe)); // "Salut à tous !"
 
 
Toutes ces fonctions intégrées sont importantes pour manipuler des tableaux, des chaînes de caractères, des objets, et bien d’autres éléments en JavaScript.
 
Elles permettent de simplifier grandement votre développement de programme et d’écrire du code connue de tous, lisible et maintenable par n’importe qui car toutes ces fonctions sont connues par vos collègues développeurs.
 
 

A retenir :

 

Les fonctions intégrées en JavaScript représentent un ensemble de méthodes indispensables pour toi développeur.

Elles permettent de manipuler facilement les chaînes de caractères, les tableaux, les objets, ainsi que d’interagir avec le système sous-jacent de JavaScript.

Ces fonctions te permette de résoudre des problèmes complexes simplement et avoir des fonctions lisible directement, maintenable par d’autres.

 

Maîtrise ces fonctions, comme splice, slice, concat, parseInt, Object.entries, entre autres, te permet non seulement de gagner en productivité, mais aussi d’écrire du code plus propre et performant pour les autres qui reprennent tes programmes ou les lisent.

 

Elles sont les fondations sur lesquelles tu peux t’appuyer et construire des applications scalables et facile a comprendre « Ne cherche pas à réinventé la roue ».

 

Alors apprend ces fonctions et découvre leurs multiples usages, tu commenceras à voir lus claire et comment elles s’intègrent dans des scénarios réels, t’aidant à écrire des programmes plus expressif et compréhensif et à résoudre des problèmes plus rapidement.

 

Allie combativité et simplicité dans l’apprentissage de JavaScript pour cela :

 

Je t’offre un Guide Bonus Exclusif

 

En allant plus loin, avec ce Guide Bonus Exclusif rien que pour Toi !

Voici un guide complet sur le JavaScript, où tu verras des techniques pour performer en programmation Js.

Ce guide te permettra de perfectionner tes compétences et de devenir un expert JavaScript. Ne le rate pas et développe ton expertise !

En adoptant ce qu’il contient, tu rends ton apprentissage de JavaScript plus performant avec une plus grande facilité tous les jours . Voici de quoi enrichir tout de suite ton savoir-faire ? Le guide complet t’attend !

 

Quelques liens en supplément de ce cours :

https://developpeur-pro.com/cours-javascript-les-bases

https://developer.mozilla.org/fr

https://stackoverflow.com/

Rejoignez notre Newsletter et Restez Informé !

Vous souhaitez rester à jour avec les dernières tendances et actualités du monde du développement et le métier de développeur. Comment devenir développeur pro ? Rejoignez notre newsletter pour obtenir un accès exclusif à du contenu premium, des astuces de codage, des mises à jour sur les nouvelles fonctionnalités et bien plus encore !

Avantages de l’Inscription

  • Restez Informé: Recevez des articles informatifs sur les dernières avancées et les meilleures pratiques de codage et les softkills.
  • Promos Exclusives: Accédez à des formations détaillés et à des exemples de code pour améliorer vos compétences en programmation.
  • Aperçus des Nouveautés: Soyez parmi les premiers à découvrir les nouvelles fonctionnalités et les frameworks émergents dans l’écosystème du développement FrontEnd et Backend.
  • Communauté Engagée: Rejoignez une communauté passionnée de développeurs et partagez vos idées, questions et expériences.

Comment S’Inscrire

C’est simple et rapide ! Remplissez le formulaire d’inscription avec votre adresse e-mail et cliquez sur « S’Inscrire ». Vous recevrez régulièrement notre newsletter dans votre boîte de réception.

L’inscription à notre newsletter est un moyen idéal de rester informé et de progresser dans le domaine de la programmation et du développement pour devenir un développeur professionnel ou une développeuse pro.

S'inscrire Maintenant

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *