« Programmation JavaScript/Variables » : différence entre les versions

Si aucune condition n'est remplie et que l'expression affecte une valeur à la variable, cette variable est créée comme propriété de l'objet global. Si l'expression ne fait qu'utiliser la valeur, elle retournera simplement '''undefined'''.

 

d="propriété de window"

 

alert(window.d) // affiche "propriété de window"

}

 

=== Variables locales ===

Comme toute variable locale, elle est automatiquement détruite à la fin de la fonction, bien que sa valeur puisse être sauvegardée dans certains cas (voir [[../Closure]]). Par contre, elle ne peut pas être détruite par l'opérateur [[../Opérateurs#Dé-référencement (delete)|delete]].

 

function foo()

{

}

alert(loc_2); // Provoque une erreur

 

Si la déclaration '''var''' est utilisée en-dehors de toute fonction, la variable sera utilisable dans tout le script.

Une variable est du type undefined dans trois cas:

* Après déclaration '''var''' sans affectation

var maNouvelleVar; // Déclarée mais pas affectée

alert(typeof maNouvelleVar); // Affiche undefined

* Si on lui affecte explicitement la valeur <code>undefined</code>, ou qu'on lui affecte le résultat d'une expression qui retourne cette valeur.

var jeSaisPas = undefined

var caNExistePas = "impossible".enFrancais

alert (typeof jeSaisPas) // Affiche undefined

alert (typeof caNExistePas) // Affiche undefined

* Si elle n'a pas été déclarée ni utilisée, ou bien qu'elle a été effacée par l'opérateur [[../Opérateurs#Dé-référencement (delete)|delete]].

alert(typeof varPasDeclaree); // Affiche undefined (si elle n'a effectivement pas été affectée)

monEphemere = "exister";

 

alert(varPasDeclaree) // erreur !!

 

À noter : dans les deux premiers cas, la variable existe et possède une valeur (<code>undefined</code>). On peut lire cette valeur sans provoquer d'erreur. Dans le troisième cas cependant, la variable n'existe pas : l'opérateur <code>typeof</code> retourne "undefined", mais lire directement la valeur de la variable provoque une erreur.

=== number ===

JavaScript réunit en un seul type les entiers, petits et grands, les décimaux, et les réels, flottants ou pas.

r = 1/3;

alert(r); // affiche 0.333333333333

0x40 // 64 en notation hexadécimale

0100 // 64 en notation octale

 

Concrètement, les nombres sont stockés sur 64 bits, avec une mantisse de 53 bits. Cela permet des valeurs entières jusqu'à 9 007 199 254 740 991, à partir duquel on commence à perdre de la précision jusqu'à 2^1024-1 qui est la valeur flottante la plus élevée représentable en JavaScript.

En fait, JavaScript inclut également dans le type '''number''' deux valeurs spéciales. '''Infinity''', un nombre signé, est renvoyé dès que le résultat dépasse la capacité de stockage de '''number''', mais aussi dans des cas limites simples. Dans les cas indécidables, ou bien lorsqu'une opération qui retourne un nombre ne peut pas le faire, c'est la valeur '''NaN''' (Not A Number) qui est renvoyée (voir les [[../Opérateurs#Opérateurs arithmétiques|opérateurs arithmétiques]], [[../Number|les méthodes de Number]] et [[../Math|les méthodes de Math]] pour les cas qui produisent ces deux valeurs).

 

1/0 == Infinity

-2 / Infinity == 0

0/0 == NaN

Number("texte") == NaN

 

=== string ===

=== boolean ===

Une variable de type boolean accepte deux valeurs : vrai et faux.

b = true;

alert(typeof b); // Affiche "boolean"

c = (5 == 3); // est faux, mais l'expression est booléenne.

alert(typeof c); // Affiche "boolean"

 

Dans une comparaison, les valeurs suivantes sont équivalentes ([[../Opérateurs#Égalité (==, ===)|opérateur '''==''']]) à '''false''' :

 

L'instanciation explicite d'un objet grâce à un constructeur s'effectue avec [[../Opérateurs#Instanciation (new)|l'opérateur '''new''']].

t = new Array();

alert(typeof t) // Affiche "object"

 

Les expressions littérales de chaînes, nombres et booléens créent des variables scalaires alors que le constructeur de ces types crée un objet (explicitement de type '''object''' et donc strictement différents d'une valeur scalaire équivalente). Mais les expressions littérales de fonctions, tableaux et expressions rationnelles créent des objets, car ce ne sont pas des types scalaires. Ces objets, instanciés sans utilisation de '''new''', sont néanmoins strictement identiques à leur équivalent produit par l'appel d'un constructeur. Par exemple :

 

// valeur scalaire vs. objet

"chaîne" !== new String("chaîne")

["a", "b", "c"] === new Array("a", "b", "c")

/(\w+) ?\(/i === new RegExp("(\w+) ?\(", "i")

 

On peut créer un objet générique (qui sera simplement une instance de la "classe" [[../Object|'''Object''']]) avec la notation littérale. Cela consiste à écrire, entre accolades, une liste de couples clé : valeur séparés par des virgules, la clé pouvant être un identifiant ou bien une chaîne, et la valeur pouvant être n'importe quelle valeur. La clé et la valeur sont séparés par deux points (':').

 

objetLitteral = {

nom : "Mac OS X",

"nom de code" : "Leopard"

}

Attention, dans l'exemple ci-dessus, on ne pourra accéder à la dernière propriété ("nom de code") de l'objet qu'avec la notation tableau (avec des crochets), pas la notation objet (avec des points) car ce n'est pas un identifiant valide (il y a des espaces dedans).

 

 

Une fonction est créée par l'expression littérale (exemple ci-dessous) ou bien par le constructeur Function.

function fibonacci( n )

{

return v

}

 

Cette déclaration crée une variable "fibonacci" qui référence la fonction, mais c'est aussi une opération qui retourne la référence de la fonction, que l'on peut ainsi affecter à une autre variable. Il est d'ailleurs possible de déclarer une fonction anonyme. De plus, toute nouvelle fonction reçoit automatiquement une propriété '''prototype''' identique au prototype de la fonction Object.

L'appel se fait en ouvrant et fermant une paire de parenthèses juste après une expression dont la valeur est de type "function". Cette expression n'est pas obligatoirement le nom d'une fonction, ni même un identifiant. Cette signification des parenthèses est prioritaire sur la signification générale (forcer une expression à être évaluée avant celles qui l'entourent).

 

f = fibonacci

delete fibonacci // efface seulement la variable, pas la fonction, qui est toujours référencée par f

x = f(10); // Constitue l'appel de la fonction fibonacci, en lui passant un argument

alert(f) // affiche le code de la fonction, y compris le nom donné dans sa déclaration, "fibonacci"

 

Les opérateurs et méthodes qui acceptent des objets comme opérande ou argument fonctionnent pareil avec des fonctions, notamment le point pour accéder aux propriétés de la fonction.