mozilla
Vos résultats de recherche

    Objets élémentaires JavaScript

    Dans ce chapitre nous verrons les différents objets élémentaires qui existent en JavaScript : Array, Boolean, Date, Function, Math, Number, RegExp, et String.

    Les tableaux : objet Array

    JavaScript ne possède pas type primitif pour les tableaux. En revanche, il est possible d'utiliser l'objet natif Array ainsi que ses méthodes pour manipuler des tableaux. L'objet Array possède différentes méthodes pour manipuler les tableaux : fusion, inverse, tri... Il possède une propriété permettant de déterminer la longueur du tableau et d'autres propriétés qu'on peut utiliser avec les expressions rationnelles.

    Un tableau est un ensemble ordonné de valeurs auxquelles on peut faire référence via un nom et un indice. Si par exemple on utilise un tableau reg qui contient un registre de noms indicés (autrement dit dont la position dans le tableau est déterminée) par un identifiant : on aurait reg[1] pour le premier nom, reg[2] pour le second et ainsi de suite/

    Créer un tableau :

    Les instructions suivantes permettent de créer des objets Array équivalents :

    var arr = new Array(element0, element1, ..., elementN);
    var arr = Array(element0, element1, ..., elementN);
    var arr = [element0, element1, ..., elementN];
    

    element0, element1, ..., elementN est la liste des valeurs des éléments du tableau. Quand ces valeurs sont fournies, les éléments du tableau sont initialisés avec ses valeurs. La propriété length vaudra alors le nombre d'arguments.

    La dernière syntaxe, utilisant des crochets, est appelée « littéral de tableau » ou « initialisateur de tableau ». C'est la forme la plus courte pour créer un tableau et c'est cette forme qui est souvent préférée. Voir la page Littéraux de tableaux pour plus de détails.

    Lorsqu'on souhaite créer un tableau de longueur non nulle mais qui ne contient aucun élément, les syntaxes suivantes peuvent être utilisées :

    var arr = new Array(longueurTabl);
    var arr = Array(longueurTabl);
    
    // Ces instructions ont le même effet
    var arr = [];
    arr.length = longueurTabl;
    

    Dans le code ci-dessus, longueurTabl doit être du type Number. Si ce n'est pas le cas, un tableau avec une seule valeur, celle fournie, longueurTabl, sera créé. Si on appelle arr.length, on aura bien longueurTabl, en revanche le tableau ne contiendra que des éléments vides (indéfinis). Si on utilise une boucle for...in sur le tableau, aucun des éléments du tableau ne sera renvoyé.

    En plus de définir une nouvelle variable en lui assignant un tableau, on peut également assigner les tableaux à une propriété d'un nouvel objet ou d'un objet existant :

    var obj = {};
    // ...
    obj.prop = [element0, element1, ..., elementN];
    
    // OU
    var obj = {prop: [element0, element1, ...., elementN]}
    

    Si on souhaite initialiser un tableau avec un seul élément qui est un nombre, on doit utiliser la syntaxe avec crochets. En effet, si on utilise le constructeur Array() auquel on passe un seul argument numérique, celui-ci sera interprété comme longueurTabl, et non pas comme le seul élément du tableau.

    var arr = [42];
    var arr = Array(42); // Crée un tableau sans élément mais de longueur 42
    
    // L'instruction ci-avant est équivalente à
    var arr = [];
    arr.length = 42;
    
    

    Si on appelle le constructeur Array() avec un argument qui n'est pas un nombre entier (dont la partie décimale est non nulle), on obtiendra une erreur RangeError. Voici un exemple :

    var arr = Array(9.3);  // RangeError: Invalid array length
    

    Si on souhaite créer des tableaux d'un seul élément (peu importe le type), il est plus adapté d'utiliser des littéraux de tableaux ou de créer un tableau vide puis d'y ajouter la valeur.

    Remplir un tableau

    Il est possible de remplir un tableau en affectant des valeurs à ses différents éléments :

    var reg = [];
    reg[0] = "Casey Jones";
    reg[1] = "Phil Lesh";
    reg[2] = "August West";
    

    Note : Si on utilise les crochets et un nombre décimal non entier, une propriété sera créée pour l'objet mais cela ne créera pas un élément du tableau.

     var arr = [];
    arr[3.4] = "Oranges";
    console.log(arr.length);                // 0
    console.log(arr.hasOwnProperty(3.4));   // true
    

    On peut également remplir un tableau à la création :

    var monTableau = new Array("Hello", maVar, 3.14159);
    var monTableu = ["Mangue", "Pomme", "Orange"]
    

    Faire référence aux éléments d'un tableau

    Il est possible de faire référence aux élément d'un tableau en utilisant leur indice dans ce tableau. Ainsi, si on définit le tableau suivant :

    var monTableau = ["Vent", "Eau", "Feu"];
    

    On peut faire référence au premier élément du tableau en utilisant monTableau[0] et au second élément en utilisant monTableau[1]. Les indices des éléments d'un tableau commencent à zéro.

    Note : L'opérateur du tableau (les crochets) est aussi utilisé pour accéder aux propriétés du tableau (en effet les tableaux sont des objets en JavaScript, et on peut donc utiliser leurs propriétés). Par exemple :

     var tabl = ["un", "deux", "trois"];
    tabl[2];  // trois
    tabl["length"];  // 3
    

    La propriété length

    En termes d'implémentation, les éléments d'un tableau sont en fait stockés comme des propriétés de l'objet et l'indice de l'élément est le nom de la propriété. La propriété length est spéciale : elle renvoie toujours l'indice du dernier élément plus 1. Attention : les indices d'un tableau, en JavaScript, commencent à 0 et pas à 1.

    var chats = [];
    chats[30] = ['Nyan'];
    print(chats.length); // 31
    

    Il est également possible d'affecter une valeur à la propriété length. Si on lui assigne une valeur inférieure au nombre d'éléments du tableau : le tableau sera tronqué. Si on lui affecte la valeur 0, le tableau sera entièrement vidé.

    var chats = ['Marie', 'Toulouse', 'Berlioz'];
    console.log(chats.length); // 3
    
    chats.length = 2;
    console.log(chats); // affiche "Marie,Toulouse" - Berlioz a été retiré
    
    chats.length = 0;
    console.log(chats); // Rien n'est affiché : tableau vide
    
    chats.length = 3;
    console.log(cats); // [undefined, undefined, undefined]
    

    Effectuer des boucles sur des tableaux

    On sera souvent amené à faire des boucles sur les valeurs d'un tableau pour répéter un traitement sur chacune d'elle. La façon la plus simple de faire des boucles est la suivante :

    var couleurs = ['rouge', 'vert', 'bleu'];
    for (var i = 0; i < couleurs.length; i++) {
      console.log(couleurs[i]);
    }
    

    Si on est certain qu'aucun des éléments du tableau ne pourra être évalué à false. Si par exemple le tableau est constitué d'éléments du DOM, on peut utiliser la syntaxe suivante, plus efficace :

    var divs = document.getElementsByTagName('div');
    for (var i = 0, div; div = divs[i]; i++) {
      /* Effectuer un traitement sur les div */
    }
    

    En faisant cela, on évite de répéter le test qui consiste à vérifier la longueur du tableau et on s'assure que la variable div est réassignée à chaque passage dans la boucle.

    Introduit dans JavaScript 1.6

    La méthode forEach(), introduite avec JavaScript 1.6, permet de boucler sur un tableau d'une autre façon :

    var couleurs = ['rouge', 'vert', 'bleu'];
    couleurs.forEach(function(couleur) {
      console.log(couleur);
    });
    

    La fonction, passée en argument de la méthode forEach est exécutée pour chaque élément du tableau (qui sera passé en argument de cette fonction). Les éléments du tableau non assignés ne sont pas traités.

    Les éléments du tableau qui n'ont pas été définis lors de la création du tableau ne sont pas utilisés avec forEach, en revanche lorsque undefined a été explicitement assigné à un élément du tableau, il est pris en compte :

    var array = ['premier', 'second', , 'quatrième'];
    
    // la boucle ci-dessous renvoie ['premier', 'second', 'quatrième'];
    array.forEach(function(element) {
      console.log(element);
    })
    
    if(array[2] === undefined) { console.log('array[2] vaut undefined'); } // true
    
    var array = ['premier', 'second', undefined, 'quatrième'];
    
    //la boucle ci-dessous renvoie ['premier', 'second', undefined, 'quatrième'];
    array.forEach(function(element) {
      console.log(element);
    })

    Les éléments d'un tableau étant stockés comme des propriétés d'un tableau, il n'est pas conseillé d'utiliser de boucle for...in pour traiter les tableaux car on traitera les éléments du tableau ainsi que toutes les propriétés énumérables.

    Méthodes de l'objet Array

    L'objet Array possède les méthodes suivantes :

    • concat() : fusionne deux tableaux et renvoie le résultat de cette fusion
      var monTableau = new Array("1", "2", "3");
      monTableau = monTableau.concat("a", "b", "c"); // monTableau vaut maintenant ["1", "2", "3", "a", "b", "c"]
      
    • join(délimiteur = ",") fusionne les éléments d'un tableau en une seule chaîne, en utilisant un délimiteur :
      var monTableau = new Array("Air", "Eau", "Feu");
      var liste = monTableauArray.join(" - "); // "Air - Eau - Feu"
      
    • push() ajoute un ou plusieurs éléments à la fin d'un tableau et retourne la longueur du tableau après cet ajout :
      var monTableau = new Array("1", "2");
      monTableau.push("3"); // monTableau vaut maintenant ["1", "2", "3"]
      
    • pop() retire le dernier élément d'un tableau et renvoie cet élément :
      var monTableau = new Array("1", "2", "3");
      var dernier = monTableau.pop(); // monTableau vaut ["1", "2"] et dernier = "3"
      
    • shift() retire le premier élément du tableau et renvoie cet élément :
      var monTableau = new Array ("1", "2", "3");
      var premier = monTableau.shift(); // monTableau vaut ["2", "3"], premier vaut "1"
      
    • unshift() ajoute un ou plusieurs éléments en premier(s) élément(s) dans un tableau et renvoie la nouvelle longueur :
      var monTableau = new Array ("1", "2", "3");
      monTableau.unshift("4", "5"); // monTableau devient ["4", "5", "1", "2", "3"]
    • slice(indice_debut, jusqu_indice) extrait une portion d'un tableau et renvoie un nouveau tableau :
      var monTableau = new Array ("a", "b", "c", "d", "e");
      monTableau = monTableau.slice(1, 4); /* commencer à 1 et jusqu'à l'indice 3, renvoyant
       ainsi [ "b", "c", "d"] */
      
    • splice(indice, nombre_a_enlever, ajout_element1, ajout_element2, ...) retire des éléments d'un tableau et les remplace si des valeurs sont fournies :
      var monTableau = new Array ("1", "2", "3", "4", "5");
      monTableau.splice(1, 3, "a", "b", "c", "d"); // monTableau vaut ["1", "a", "b", "c", "d", "5"]
        // ce code commence à l'indice 1 (où il y a la valeur "2"), retire 3 éléments
        // puis insère les éléments fournis à partir de cet indice
      
    • reverse() transpose les éléments d'un tableau : le premier élément du tableau et le dernier devient le premier :
      var monTableau = new Array ("1", "2", "3");
      monTableau.reverse(); // transpose le tableau qui devient [ "3", "2", "1" ]
      
    • sort() trie les éléments d'un tableau :
      var monTableau = new Array("Air", "Eau", "Feu");
      monTableau.sort(); // trie le tableau qui devient [ "Air", "Eau", "Feu" ]
      

      sort() peut également prendre en argument une fonction de rappel (callback en anglais) qui détermine la relation d'ordre selon laquelle les éléments sont comparés. Cette fonction compare deux valeurs et renvoie l'une de ces trois valeurs :

      • Si a est inférieur à b selon la relation d'ordre : -1 (ou tout autre nombre négatif)
      • Si a est supérieur à b selon la relation d'ordre : 1 (ou tout autre nombre positif)
      • Si a et b sont égaux selon la relation d'ordre : 0.

      Par exemple, on peut utiliser la fonction ci-après pour trier selon la dernière lettre d'un tableau :

      var triFn = function(a, b){
        if (a[a.length - 1] < b[b.length - 1]) return -1;
        if (a[a.length - 1] > b[b.length - 1]) return 1;
        if (a[a.length - 1] == b[b.length - 1]) return 0;
      }
      monTableau.sort(triFn); // tri le tableau qui deviendra 
      //monTableau = ["Air","Eau","Feu"]

    Introduit dans JavaScript 1.6

    Du code compatible avec les anciens navigateurs, pour remplacer ces fonctions, est disponible sur les pages qui concernent ces fonctions. Le support des navigateurs pour ces fonctions est détaillé ici (en anglais).

    • indexOf(élémentCherché[, indiceDebut]) permet de chercher dans le tableau l'élément élémentCherché et renvoie le premier indice où l'élément est trouvé.
      var a = ['a', 'b', 'a', 'b', 'a'];
      alert(a.indexOf('b')); // Affiche 1
      // Ensuite, on cherche après la première correspondance
      alert(a.indexOf('b', 2)); // Affiche 3
      alert(a.indexOf('z')); // Affiche -1 car 'z' n'a pas été trouvé
      
    • lastIndexOf(élémentCherché[, indiceDebut]) fonctionne comme indexOf, mais cherche à partir de la fin du tableau.
      var a = ['a', 'b', 'c', 'd', 'a', 'b'];
      alert(a.lastIndexOf('b')); // Affiche 5
      // Ensuite on cherche avant la dernière correspondance
      alert(a.lastIndexOf('b', 4)); // Affiche 1
      alert(a.lastIndexOf('z')); // Affiche -1
      
    • forEach(callback[, thisObject])exécute la fonction callback sur chaque élément du tableau.
      var a = ['a', 'b', 'c'];
      a.forEach(alert); // Affiche chaque élément
      
    • map(callback[, thisObject]) renvoie un nouveau tableau composé des résultats de l'application de la fonction callback sur chaque élément du tableau initial
      var a1 = ['a', 'b', 'c'];
      var a2 = a1.map(function(item) { return item.toUpperCase(); });
      alert(a2); // affiche A,B,C
      
    • filter(callback[, thisObject]) renvoie un nouveau tableau composé des éléments du tableau initial pour lesquels la fonction callback a renvoyé true.
      var a1 = ['a', 10, 'b', 20, 'c', 30];
      var a2 = a1.filter(function(item) { return typeof item == 'number'; });
      alert(a2); // affiche 10,20,30
      
    • every(callback[, thisObject]) renvoie true si la fonction callback renvoie true pour chaque élément du tableau
      function isNumber(value){
        return typeof value == 'number';
      }
      var a1 = [1, 2, 3];
      alert(a1.every(isNumber)); // Affiche true
      var a2 = [1, '2', 3];
      alert(a2.every(isNumber)); // Affiche false
      
    • some(callback[, thisObject]) renvoie true si la fonction callback renvoie true pour au moins un élément du tableau
      function isNumber(value){
        return typeof value == 'number';
      }
      var a1 = [1, 2, 3];
      alert(a1.some(isNumber)); // Affiche true
      var a2 = [1, '2', 3];
      alert(a2.some(isNumber)); // Affiche true
      var a3 = ['1', '2', '3'];
      alert(a3.some(isNumber)); // Affiche false
      

    Les méthodes ci-dessus utilisent des fonctions de rappel (callback) et sont appelées méthodes itératives. En effet, d'une certaine façon, elles bouclent sur le tableau. Chacune de ces méthodes possède un argument facultatif thisObject. Si cet argument est utilisé, il représentera le contexte utilisé pour le mot-clé this utilisé dans la fonction de rappel. S'il n'est pas utilisé et que la fonction est appelée en dehors d'un contexte objet donné this fera référence à l'objet global (window). Pour plus d'informations, voir la page sur this.

    En réalité, la fonction de rappel est utilisé avec trois arguments. Le premier est la valeur de l'élément, le deuxième est l'indice de l'élément et le troisième est la référence au tableau. Étant donné que JavaScript ignore les arguments en trop pour une fonction, on peut très bien appeler une fonction qui ne prend qu'un seul paramètre (comme alert par exemple).

    Introduit dans JavaScript 1.8

    • reduce(callback[, initialValue]) applique la fonction callback(valeur1, valeur2) afin de réduire le tableau à une seule valeur.
      var a = [10, 20, 30];
      var total = a.reduce(function(premier, second) { return first + second; }, 0);
      alert(total) // Affiche 60
      
    • reduceRight(callback[, initialValue]) fonctionne comme reduce() mais en partant du dernier élément.

    reduce et reduceRight sont des méthodes itératives plus compliquées. Ces méthodes sont à utiliser pour des algorithmes récursifs pour réduire une séquence d'objet en une seule valeur.

    Tableaux à plusieurs dimensions

    Les tableaux peuvent être imbriqués, cela signifie qu'un tableau peut contenir un autre tableau comme élément. De cette façon, on peut créer des tableaux à plusieurs dimensions.

    Voici par exemple la création d'un tableau de dimension 2.

    var a = new Array(4);
    for (i = 0; i < 4; i++) {
      a[i] = new Array(4);
      for (j = 0; j < 4; j++) {
        a[i][j] = "[" + i + "," + j + "]";
      }
    }
    

    Le code précédent permettra de créer un tableau avec ces lignes :

    Ligne 0: [0,0] [0,1] [0,2] [0,3]
    Ligne 1: [1,0] [1,1] [1,2] [1,3]
    Ligne 2: [2,0] [2,1] [2,2] [2,3]
    Ligne 3: [3,0] [3,1] [3,2] [3,3]
    

    Tableaux et expressions rationnelles

    Lorsqu'un tableau provient d'une correspondance entre une expression rationnelle et une chaîne de caractères, le tableau possède des propriétés et des éléments fournissant des informations sur la correspondance. Un tel tableau peut être renvoyé par RegExp.exec(), String.match(), et String.split(). Pour plus d'informations sur l'utilisation des tableaux et des expressions rationnelles, voir la page Expressions rationnelles.

    Manipuler des objets semblables aux tableaux

    Introduit dans JavaScript 1.6

    Certains objets JavaScript, comme NodeList (renvoyé par la méthode document.getElementsByTagName()) ou arguments (disponible au sein d'une fonction) ressemblent à des tableaux et peuvent se comporter comme tels, en revanche ils ne possèdent pas toutes les propriétés d'un objet de type Array. Par exemple, l'objet arguments possède un attribut length mais ne possède pas la méthode forEach().

    Les méthodes génériques, disponibles à partir de JavaScript 1.6, permettent d'utiliser des méthodes de l'objet Array sur des objets semblables à des tableaux. Chaque méthode standard possède un équivalent disponible via l'objet Array lui-même. Ainsi :

     function alertArguments() {
       Array.forEach(arguments, function(item) {
         alert(item);
       });
     }
    

    Dans les versions plus anciennes, il est possible d'émuler ces méthodes génériques en utilisant la méthode call fournie par les fonctions :

     Array.prototype.forEach.call(arguments, function(item) {
       alert(item);
     });
    

    Ces méthodes génériques peuvent également être utilisées sur les chaînes de caractères. En effet, elles fournissent un accès séquentiel aux différents caractères, comme pour les différents éléments d'un tableau :

    Array.forEach("une chaine", function(caractere) {
       alert(caractere);
    });

    Voici d'autres exemples utilisant ces méthodes sur des chaînes de caractères. Ces exemples utilisent également les fermetures d'expressions de JavaScript 1.8 :

    var str = 'abcdef';
    var filtreConsonnes = Array.filter(str, function (c) !(/[aeiou]/i).test(c)).join(''); // 'bcdf'
    var voyellesPrésentes = Array.some(str, function (c) (/[aeiou]/i).test(c)); // true
    var toutesVoyelles = Array.every(str, function (c) (/[aeiou]/i).test(c)); // false
    var intercaleZéros = Array.map(str, function (c) c+'0').join(''); // 'a0b0c0d0e0f0'
    var valeurNumérique = Array.reduce(str, function (c, c2) c+c2.toLowerCase().charCodeAt()-96, 0);
    // 21 (reduce() since JS v1.8)
    

    Les méthodes filter et map ne renvoient pas directement les caractères comme faisant partie d'une même chaîne de caractères mais le résultat de l'opération sur chacun des caractères, il est donc nécessaire d'utiliser join pour obtenir une chaîne de caractères finale.

    Tableaux définis par compréhensions

    Introduit dans JavaScript 1.7

    À partir de JavaScript 1.7, les définitions de tableaux par compréhension permettent de construire, simplement, un tableau se basant sur le contenu d'un premier tableau. Ces compréhensions sont souvent utilisées en lieu et place des méthodes map() et filter().

    Dans l'exemple suivant, on définit un tableau par compréhension pour qu'il contienne les doubles des éléments du premier tableau :

    var nombres = [1, 2, 3, 4];
    var doubles = [i * 2 for (i of nombres)];
    alert(doubles); // Affiche 2,4,6,8
    

    Cela est équivalent à l'opération map() qui suit :

    var doubles = nombres.map(function(i){return i * 2;});
    

    Les compréhensions peuvent également être utilisées afin de restreindre un tableau à certaines valeurs correspondants à un critère. On peut par exemple ne garder que les nombres pairs :

    var nombres = [1, 2, 3, 21, 22, 30];
    var pairs = [i for (i of nombres) if (i % 2 === 0)];
    alert(pairs); // Affiche 2,22,30
    

    filter() aurait également pu être utilisé :

    var pairs = nombres.filter(function(i){return i % 2 === 0;});
    

    Les opérations du style de map() et filter() peuvent être combinées en une seule compréhension. Voici par exmple un tableau défini par compréhension qui contient les doubles des nombres pairs du premier tableau :

    var nombres = [1, 2, 3, 21, 22, 30];
    var pairsDoubles = [i * 2 for (i of nombres) if (i % 2 === 0)];
    alert(pairsDoubles); // Affiche 4,44,60
    

    Les crochets utilisés pour les définitions par compréhension permettent d'introduire une portée implicite. Les nouvelles variables (comme i dans l'exemple) sont utilisées comme si elles avaient été déclarées avec let. Elles ne seront donc pas disponibles en dehors de la compréhension.

    Il n'est pas nécessaire de partir d'un tableau pour utiliser une telle définition, on peut également utiliser les itérateurs et les générateurs.

    On peut également utiliser des chaînes de caractères comme objet de départ :

    var str = 'abcdef';
    var filtreConsonnes = [c for (c of str) if (!(/[aeiouAEIOU]/).test(c))  ].join(''); // 'bcdf'
    var intercaleZéros = [c+'0' for (c of str) ].join(''); // 'a0b0c0d0e0f0'
    

    Ici aussi, il faut utiliser la méthode join() pour obtenir une chaîne de caractère unique en sortie.

    L'objet Boolean

    L'objet Boolean est une « enveloppe » (ou wrapper en anglais) autour du type primitif booléen. La syntaxe suivante permet de créer un objet Boolean :

    var nomObjetBooléen = new Boolean(valeur);
    

    Attention, il ne faut pas confondre les valeurs true et false du type primitif booléen et les valeurs true et false de l'objet Boolean. Tout objet dont la valeur n'est pas undefined , null, 0, NaN, ou la chaîne de caractères vide (y compris un objet Boolean dont la valeur est false) sera évalué comme true dans un test conditionnel. Voir l'instruction if...else pour plus d'informations.

    Objet Date

    JavaScript ne possède pas de type de données pour gérer les dates. En revanche, il est possible d'utiliser un objet Date, ainsi que ses méthodes, pour manipuler de telles données. L'objet Date possède différentes méthodes pour définir des dates, obtenir des informations sur une dates et les manipuler, il ne possède aucune propriété.

    La gestion des dates en JavaScript est similaire à celle effectuée par Java. Les deux languages partagent de nombreuses méthodes et ils stockent tous les deux les dates comme le nombre de millisecondes depuis le premier janvier 1970 à 00h00m00 UTC.

    L'intervalle qu'on peut utiliser avec l'objet Date est entre100 000 000 jours avant le premier janvier 1970 UTC et 100 000 000 jours après.

    Pour créer un tel objet :

    var nomObjetDate = new Date([paramètres]);
    

    nomObjetDate est le nom de l'objet qu'on crée. Il peut être un nouvel objet à part entière ou bien la propriété d'un objet existant.

    Si on utilise le constructeur Date sans le mot-clé new, on obtiendra seulement la date représentée dans une chaîne de caractères.

    On peut utiliser les paramètres suivants :

    • Aucun : on crée la date et l'heure du jour : aujourdhui = new Date();.
    • Une chaîne de caractères qui représente la date au format suivant "Mois_en_anglais jour, année heures:minutes:secondes." Ainsi var Noel95 = new Date("December 25, 1995 13:30:00"). Il est possible de ne pas renseigner les heures, minutes et secondes : les valeurs par défaut seront nulles (0).
    • Un ensemble d'entiers pour l'année, le mois et le jour : var Noel95 = new Date(1995, 11, 25).
    • Un ensemble d'entiers pour l'année, le mois, le jour, l'heure, les minutes et les secondes : var Xmas95 = new Date(1995, 11, 25, 9, 30, 0);.

    Versions antérieures à JavaScript 1.2 (inclus)
    L'objet Date fonctionne de la façon suivante :

    • Les dates antérieures à 1970 ne sont pas autorisées.
    • JavaScript se repose sur des utilitaires de gestion des dates qui dépendent de la plate-forme utilisée : on obtient donc des comportements et des résultats différents en fonction de la plate-forme sur laquelle on se situe.

    Les méthodes de l'objet Date

    Les méthodes de l'objet Date sont à répartir entre quatre grandes catégories :

    • Les méthodes de définition set..., permettant de régler le jour et l'heure dans les objets Date
    • Les méthodes d'accès get..., permettant d'obtenir les valeurs de la date et de l'heure des objets Date
    • Les méthodes de conversion to..., qui permettent d'obtenir une mise en forme en chaîne de caractères
    • Les méthodes d'analyse (parsing) et les méthodes UTC, permettant de transformer certaines chaînes de caractères en Date.

    Les deux premières catégories permettent de définir ou d'obtenir les secondes, les minutes, les heures, le jour du mois, le jour de la semaine, les mois et les années. Il existe une méthode getDay pour obtenir le jour de la semaine, en revanche, il n'existe pas de méthode setDay car le calcul du jour de la semaine se fait automatiquement. Ces méthodes utilisent des entiers, de la façon suivante :

    • Les secondes et minutes : 0 à 59
    • Les heures : 0 à 23
    • Les jours : 0 (Dimanche) à 6 (Samedi)
    • La date : 1 to 31 (jour du mois)
    • Les mois : 0 (janvier) à 11 (décembre)
    • Les années : années depuis 1900

    Par exemple, si on veut définir la date suivante :

    var Noel95 = new Date("December 25, 1995");
    

    On aura alors Noel95.getMonth() qui renverra 11, Noel95.getFullYear() qui renverra 1995.

    Les méthodes getTime et setTime peuvent notamment être utilisées pour comparer des dates. La méthode getTime renvoie le nombre de millisecondes écoulées depuis le premier janvier 1970 00h00m00s pour un objet Date.

    De cette façon, le code suivant permet d'afficher le nombre de jours restants pour l'année courante :

    var ajd = new Date();
    var finAnnee = new Date(1995, 11, 31, 23, 59, 59, 999); // On règle jour et mois
    finAnnee.setFullYear(ajd.getFullYear()); // On règle l'année
    var msParJour = 24 * 60 * 60 * 1000; // Nombre de millisecondes par jour
    var joursRestants = (finAnnee.getTime() - ajd.getTime()) / msParJour;
    var joursRestants = Math.round(joursRestants); //renvoie le nombre de jours restants
    

    Dans cet exemple, on crée un objet Date qui contient la date du jour. Ensuite on crée un objet finAnnee et on fixe son année à celle du jour courant. Ensuite, en connaissant le nombre de millisecondes dans une journée, on calcule le nombre de jours entre ajd et finAnnee en utilisant la méthode getTime puis en arrondissant la valeur à un nombre entier.

    La méthode parse peut s'avérer utile lorsqu'on souhaite transformer une chaîne de caractères (en anglais, attention) en une date. L'exemple qui suit utilise les méthodes parse et setTime pour assigner une valeur de date à l'objet dateIPO :

    var dateIPO = new Date();
    dateIPO.setTime(Date.parse("Aug 9, 1995"));
    

    Exemple d'utilisation

    L'exemple qui suit permet de définir la fonction JSClock() qui renvoie l'heure au même format qu'une horloge numérique :

    function JSClock() {
      var time = new Date();
      var heure = time.getHours();
      var minute = time.getMinutes();
      var seconde = time.getSeconds();
      var temp = "" + heure;
      temp += ((minute < 10) ? ":0" : ":") + minute;
      temp += ((seconde < 10) ? ":0" : ":") + seconde;
      return temp;
    }
    

    La fonctionThe JSClock commence par créer un objet Date appelé time. Aucun argument n'est donné, c'est donc la date et l'heure courante. Ensuite, on appelle les méthodes getHours, getMinutes, et getSeconds pour connaître l'heure, les minutes et les secondes.

    Les trois instructions suivantes permettent de construire une chaîne de caractères avec la variable temp. On ajoute l'heure, puis les minutes (si celles-ci sont inférieures à 10, on rajoute un 0 devant), puis les secondes (de la même manière on rajoute un zéro devant si le nombre de secondes est inférieur à 10).

    L'objet Function

    L'objet élémentaire Function définit une chaîne de caractères de code JavaScript qui doit être compilé comme une fonction.

    Pour créer un objet Function on peut utiliser la syntaxe suivante :

    var functionNomObjet = new Function ([arg1, arg2, ... argn], corpsFonction);
    

    functionNomObjet est le nom d'une variable ou d'une propriété d'un objet. On peut également utiliser cette syntaxe avec un objet suivi par un nom de gestionnaire d'événements en minuscules comme window.onerror.

    arg1, arg2, ... argn sont les arguments qui sont utilisés par la fonction. Chacun de ces arguments doit être une chaîne de caractères qui est un identifiant JavaScript valide (ex : "x" ou "monFormulaire".

    corpsFonction est une chaîne de caractères définissant le code JavaScript qui doit être compilé comme le code de la fonction.

    Les objets Function sont évalués à chaque fois qu'ils sont utilisés. Utiliser ces objets est moins efficaces que la déclaration de fonctions qu'on appellera au sein du code. Cela est dû au fait que les fonctions déclarées sont compilées.

    En plus de la définition de fonction abordée ici, on peut également les expressions de fonction ou l'instruction function. Voir la référence JavaScript pour plus d'informations sur ces différentes syntaxes.

    Le code suivant assigne une fonction à la variable setBGColor. Cette fonction permet de définir la couleur d'arrière-plan du document courant.

    var setBGColor = new Function("document.bgColor = 'antiquewhite'");
    

    Pour appeler l'objet Function, on peut utiliser le nom de la variable comme une fonction. Le code qui suit exécute la fonction qui aura été assignée à la variable setBGColor :

    var choixCouleur="antiquewhite";
    if (choixCouleur=="antiquewhite") {setBGColor()}
    

    On peut assigner la fonction à un gestionnaire d'événements de différentes façons :

    1. document.form1.colorButton.onclick = setBGColor;
      
    2. <INPUT NAME="colorButton" TYPE="button"
        VALUE="Changer la couleur de l'arrière-plan"
        onClick="setBGColor()">
      

    La création de la variable setBGColor montrée avant est similaire à la fonction suivante :

    function setBGColor() {
      document.bgColor = 'antiquewhite';
    }
    

    Assigner une fonction à une variable est similaire à la déclaration d'une fonction, cependant il y a quelques différences :

    • Lorsqu'on assigne une fonction à une variable en utilisant la syntaxe  var setBGColor = new Function("..."), setBGColor est une variable dont la valeur courante est une référence à la fonction créée avec new Function().
    • Quand on crée une fonction en utilisant la syntaxe function setBGColor() {...}, setBGColor n'est pas une variable, c'est le nom de la fonction.

    Il est possible d'imbriquer une fonction au sein d'une fonction. La fonction imbriquée est privée, en termes de portée, pour la fonction englobante.

    • La fonction imbriquée peut être utilisée à partir d'instructions seulement depuis la fonction englobante.
    • La fonction imbriquée peut utiliser des arguments et des variables de la fonction englobante. La fonction englobante ne peut pas utiliser les arguments et les variables de la fonction imbriquée.

    L'objet Math

    L'objet élémentaire Math possède différentes propriétés et méthodes pour manipuler des constantes et des fonctions mathématiques. Ainsi, la propriété PI de cette objet possède la valeur de pi (3.141...) :

    Math.PI
    

    De la même façon, cet objet met a disposition des fonctions mathématiques qui sont des méthodes de l'objet Math. On retrouvera des fonctions trigonométriques, logarithmiques, exponentielles... Ainsi pour utiliser la fonction sinus, on écriera :

    Math.sin(1.56)
    

    Note : les arguments des méthodes trigonométriques de cet objet doivent être exprimés en radians.

    Le tableau suivant liste les différentes méthodes de l'objet Math.

    Tableau 7.1 Méthodes de l'objet Math
    Méthode Description
    abs Valeur absolue
    sin, cos, tan Fonctions trigonométriques sinus, cosinus et tangente
    acos, asin, atan, atan2 Fonctions trigonométriques inverses, les valeurs renvoyées sont exprimées en radians
    exp, log Les fonctions exponentielle et logarithme (naturel ou à base e)
    ceil Renvoie le plus petit entier supérieur ou égal à l'argument
    floor Renvoie le plus grand entier inférieur ou égal à l'argument
    min, max Renvoie le minimum ou le maximum (respectivement) des deux arguments
    pow La fonction puissance, le premier argument est la base et le second argument est l'exposant
    random Renvoie un nombre aléatoire compris entre 0 et 1
    round Arrondit l'argument au plus proche entier
    sqrt La fonction racine carrée

    Contrairement à beaucoup d'autres objets, on ne crée jamais d'objet Math personnalisé : on utilise toujours l'objet élémentaire Math.

    L'objet Number

    L'objet Number possède des propriétés correspondantes aux constantes numériques. On y trouve : la valeur maximale qu'il est possible de représenter, la valeur minimale, les infinis (négatifs et positifs), et également la constante « not a number » ou NaN qui indique que la valeur n'est pas un nombre. Ces valeurs sont fixes, ne peuvent être changées et s'utilisent de la façon suivante :

    var maximum = Number.MAX_VALUE;
    var minimum = Number.MIN_VALUE;
    var infiniPlus = Number.POSITIVE_INFINITY;
    var infiniMoins = Number.NEGATIVE_INFINITY;
    var nonNombre = Number.NaN;
    

    Il faut toujours utiliser les propriétés de l'objet Number lui-même et non pas celles d'un objet Number qui aurait été créé.

    Le tableau suivant liste les différents propriétés de l'objet Number :

    Tableau 7.2 Propriétés de l'objet Number
    Propriété Description
    MAX_VALUE Le plus grand nombre qu'on peut représenter
    MIN_VALUE Le plus petit nombre qu'on peut représenter
    NaN Valeur spéciale pour les valeurs non numériques
    NEGATIVE_INFINITY Valeur spéciale pour représenter l'infini négatif
    POSITIVE_INFINITY Valeur spéciale pour représenter l'infini positif

    Le prototype Number fournit également des méthodes pour obtenir des informations d'objets Number. Le tableau suivant liste ces différentes méthodes de Number.prototype :

    Tableau 7.3 Méthodes de Number.prototype
    Méthode Description
    toExponential Renvoie une chaîne de caractères représentant le nombre dans sa notation exponentielle.
    toFixed Renvoie une chaîne de caractères représentant le nombre dans sa notation à point fixe.
    toPrecision Renvoie une chaîne de caractères représentant le nombre dans sa notation à point fixe, avec une précision donnée.
    toSource Renvoie un littéral objet représentant l'objet Number. Cette valeur peut ensuite être utilisée pour créer un nouvel objet. Cette méthode surcharge la méthode Object.toSource.
    toString Renvoie une chaîne de caractères représentant l'objet. Cette méthode surcharge la méthode Object.toString.
    valueOf Renvoie la valeur primitive de l'objet. Cette méthode surcharge la méthode Object.valueOf.

    L'objet RegExp

    Pour plus d'explications sur le fonctionnement des expressions rationnelles, voir la page sur les expressions rationnelles.

    L'objet String

    L'objet String est une enveloppe pour les données du type chaîne de caractères. Les littéraux de chaînes de caractères ne doivent pas être confondus avec les objets String. Par exemple, le code suivant crée deux choses : un littéral de chaîne de caractère, s1, et l'objet String s2 :

    var s1 = "truc"; //crée un littéral de chaîne de caractères
    var s2 = new String("truc"); //crée un objet String
    

    Chacune des méthodes de l'objet String peut être utilisée sur une valeur qui est un littéral de chaîne de caractères (pour ce faire, JavaScript convertit automatiquement le littéral en un objet String temporaire, appelle la méthode voulue puis supprime l'objet temporaire). Il est également possible d'utiliser la propriété String.length sur un littéral de chaîne de caractères.

    Il est fortement recommandé d'utiliser des littéraux de chaînes de caractères à moins d'avoir spécifiquement besoin d'utiliser un objet String. En effet, les objets String peuvent avoir des effets inattendus :

    var s1 = "2 + 2"; //crée un littéral de chaîne de caractères
    var s2 = new String("2 + 2"); //crée un objet String
    eval(s1); //renvoie 4
    eval(s2); //renvoie la chaîne "2 + 2"

    Un objet String possède une seule propriété, length, indiquant le nombre de caractères contenus dans la chaîne de caractères. Dans le code qui suit, x recevra la valeur 13 car la chaîne "Hello, World!" possède 13 caractères :

    var maChaine = "Hello, World!";
    var x = maChaine.length;
    

    Un objet possède deux types de méthodes : celles qui renvoient une chaîne modifiée à partir de l'objet initial et celles qui renvoient une version au format HTML de la chaîne. Dans la première catégorie on trouvera des méthodes comme substring et toUpperCase, dans la seconde catégorie, on trouvera notamment bold et link.

    Par exemple, si on utilise la chaîne précédente maChaine.toUpperCase() ou aussi "hello, world!".toUpperCase(), on obtiendra le résultat "HELLO, WORLD!".

    La méthode substring contient deux arguments et renvoie un fragment de la chaîne de caractères entre ces deux arguments qui correspondent aux indices de début et de fin du « découpage ». maChaine.substring(4, 9) renverra "o, Wo".

    L'objet String possède également certaines méthodes permettant d'obtenir directement des données au format HTML : des liens, du texte formaté... Ainsi on pourrait créer un hyperlien avec la méthode suivante :

    maChaine.link("http://www.helloworld.com")
    

    Le tableau qui suit liste les méthodes des objets String.

    Tableau 7.4 Méthodes des instances du prototype String
    Méthode Description
    anchor Permet de créer un ancre HTML
    big, blink, bold, fixed, italics, small, strike, sub, sup Permet de formater une chaîne de caractères au format HTML. (Note : l'utilisation du CSS peut parfois être plus judicieuse que certaines entités HTML).
    charAt, charCodeAt Renvoie le caractère ou le code du caractère à la position indiquée dans la chaîne de caractères.
    indexOf, lastIndexOf Renvoie la position d'un fragment de la chaîne de caractères (respectivement la dernière position).
    link Crée un hyperlien HTML
    concat Concatène deux chaînes de caractères en une chaîne de caractères.
    fromCharCode Construit une chaîne de caractères à partir de la séquence de codes Unicodes fournie. Cette méthode appartient au prototype String mais pas aux instances objets String.
    split Découpe un objet String en un tableau de chaînes de caractères selon un séparateur donné.
    slice Extrait un fragment de la chaîne de caractères et renvoie une nouvelle chaîne.
    substring, substr Renvoie un fragment de la chaîne de caractères à partir d'un indice jusqu'à un autre indice ou à partir d'un indice et pour une longueur donnée.
    match, replace, search Fonctionne avec les expressions rationnelles.
    toLowerCase, toUpperCase

    Renvoie la chaîne de caractères en lettres minuscules (respectivement, en lettres majuscules).

    « Précédent  Suivant »

    Étiquettes et contributeurs liés au document

    Contributors to this page: teoli, Goofy, SphinxKnight
    Dernière mise à jour par : SphinxKnight,
    Masquer la barre latérale