Attention: les résultats obtenus peuvent varier en fonction du navigateur utilisé et de la version java script spécifiée.
Les valeurs entre parenthèse (Pxxx) font référence à un livre écrit par Michel Dreyfus et qui s'appel "JavaScript et Jscript" édité chez SYBEX. Ce livre est cher, bourré de faute de d'impression et de typographie, mais il est quand même très utile pour les débutants ayant par ailleurs des notions de langage de programmation.

Les commandes java peuvent se trouver n'importe ou dans le document Html (aussi bien dans l'entête que dans le corps du document). Elles se trouvent entre des balises <script> et </script>. Dans la commande <script> on peut préciser le type de langage ex: <script language="JavaScript1.2">. Si le navigateur ne reconnaît pas le Javascript 1.2 alors il ignorera le contenu du script.
Le script peut aussi se trouver dans un fichier à part. Il est alors invoqué par la commande <script src = "script.js"> </script>. 'script.js' représente le nom du fichier contenant le script (extension .js par défaut). L'option 'language = "JavaScript" ' peut être utilisée dans la balise.
Commentaire sur une seul ligne  //
Commentaire sur plusieurs lignes: début/*
                                                       fin */
Javascript fait la différence entre les majuscules et les minuscules, donc partout ou il y à une majuscule c'est qu'elle est obligatoire.

L'instruction document.write("123") permet d'écrire dans un document Html. Elle utilise la norme Html pour écrire(balise Html). Attention la présence de plusieurs espaces consécutifs est remplacer par un seul espace par Javascript y compris dans les chaînes de caractères. Pour ne pas perdre la présentation à l'affichage utiliser les balises <pre></pre>. ou alors remplacer les espaces par "&nbsp;".

Une même instruction peut se trouver sur plusieurs lignes et pour séparer plusieurs instructions ecrite sur une même ligne, on doit utiliser un point virgule.

Les constantes
Les angles sont toujours exprimé en radian.
Une constante décimale ne doit pas commencer par un zéro.
Une constante octale commence toujours par un zéro.
Une constante hexadécimale commence toujours par 0X.

Infinity est une constante supérieure a tous les nombres.
Nan signifie "Not a Number", ce n'est pas un nombre.
Null signifie "pas de valeur" ou "pas d'objet".
Undefined signifie "pas encore définie".
Max_value donne la valeur maximum que peut prendre un nombre. Ex: "number.max_value" vaut 1.7976931348623157E+308.
Min_value donne la valeur minimum que peut prendre un nombre. Ex: "number.min_value"vaut 5E-324.
Positiv_infinity     donne "infinity".
Negative_infinity donne "-infinity".
Si une chaîne est trop longue on peut la continuer sur la ligne du dessous en utilisant un anti-slache en fin de ligne.
Constantes booléennes: "true" ou "false".

Caractères spéciaux. Ils sont utilisés dans l'affichage des boites de dialogue.
 \b espacement arrière.
 \f saut de page.
 \n saut de ligne.
 \r retour chariot.
 \t tabulation.
 \' apostrophe.
 \" guillemet.
 \\ anti-slache.
 \XXX caractère latin codifier en octale.
 \xXXX caractère latin codifier en hexadécimal.
 \uXXX caractère uni code codifier en hexadécimal.

Les variables
Les variables ne sont pas obligatoirement typées. Le fait de comparer une variable chaîne avec une constante numérique n'est pas une erreur, par contre le résultat peut être surprenant.
La déclaration des variables n'est pas obligatoire, mais peut ce fait par la commande var. Ex: var toto; var long = 45; var nom = "Michel". La déclaration est implicite au moment d'une affectation. Ex:  long = 50.
Java script n'est pas formelle sur le type des variables. Une variable peut changer de type en fonction d'une nouvelle déclaration ou d'une affectation. Comparer une variable numérique à une variable chaîne ne lui pose pas de problème de même qu'additionner une chaîne avec un nombre. Attention les variables déclarer avec l'instruction var dans une fonction seront des variables local, les variables déclarer implicitement (x=75) seront toujours des variables général. Dans certains cas la déclaration de variables peut s'avérer nécessaire surtout pour les tableaux.
delete permet d'effacer une variable à condition qu'elle n'est pas était déclaré avec var.
Déclaration de type de variable:
toto = new Boolean(true) toto est une variable booléenne qui vaut "true" par défaut la variable vaut "false".
new Number() par défaut la variable vaut zéro.
new String() par défaut la variable est une chaîne vide.
new Date() par défaut affecte la date et l'heure du PC à la variable.
new Image() crée une variable à qui l'on pourra affecter une image en vue de sont pré-chargement pour un affichage plus rapide. Ex: x=new Image(); x.src="toto.gif"
new RegExp() transforme une chaîne en expression régulière.

Les variables peuvent être assemblées ensemble pour créer une nouvelle variable. Ex: toto=123; texte="abcd"; toto.texte="nouvelle variable". On peut associer une valeur par défaut à cet assemblage.
.prototype associe une valeur par défaut à un assemblage de variable. Ex: String.prototype.texte="xyz" à partir de maintenant toutes les variable.texte sont égal à "xyz" par défaut. On peut compléter par Number.prototype.texte="aeiou". Si fifi est une chaîne alors fifi.texte est égale par défaut à "xyz", mais si fifi est un nombre alors fifi.texte est égal par défaut à "aeiou".

typeof() renvoie le type de la variable x sous la forme "string", "number", "undefined", "fonction", "objet". Ex: x=typeof (toto) (P59).
.constructor renvoie function String() { [native code] } si c'est un chaîne, function Number() { [native code] } si c'est un nombre, function Boolean() { [native code] } si c'est une variable booléenne, function Date() { [native code] }si c'est une date, function Array() { [native code] } si c'est un tableau et Function() { [native code] } si c'est une fonction. Ex: x=toto.constructor (P260).

Les fonctions chaînes
Les chaînes sont en fait des tableaux de caractères qui ne sont pas séparer par des virgules, l'indice 0 représente le premier caractère de la chaîne. Il est donc normal que de nombreuses fonctions soit similaire au deux.
.charAt(x) renvoie le caractère placer en position x dans la chaîne(x de 0 à .length-1) Ex: x="azert".charAt(2) (P265).
.charCodeAt(x) renvoie en décimal l'unicode du caractère placer en position x. Ex: x=toto.charCodeAt(2) (P266).
.length renvoie la longueur de la chaîne ou undefined si ce n'est pas une chaîne. Ex: x="azert".length
.concat() met bout à bout des chaînes. Ex: ch1=concat(ch2,ch3,ch4), au bout de la chaîne ch1 ont été rajouté les chaînes ch2, ch3 et ch4 dans l'ordre (P267).
.fromCharCode(x) constitue une chaîne à partir de code unicode. Ex: toto=String.fromCharCode(65,66,82) (P270).
.indexOf() renvoie la première position d'une chaîne à l'intérieur d'une autre.(La recherche se fait de gauche à droite) Ex: x=chaine1.indexOf(chaine2) (P271).
.lastIndexOf() renvoie la dernière position d'une chaîne à l'intérieur d'une autre.(La recherche se fait de droite à gauche) Ex: x=chaine1.lastIndexOf(chaine2) (P272).
.slice(x,y) extrait une chaîne d'une autre chaîne. x est la position de départ y la position d'arrivé, si y est négatif on compte à partir de la droite (P274).
.substr(x,y) extrait une chaîne d'une autre chaîne. x est la position de départ, y la longueur de chaine extraite, si x est négatif, on compte à partir de la droite (P277).
.substring(x,y) même chose que les deux précédentes (P278).
.split(x,y) transforme une chaîne en un tableau le séparateur x est transformé en virgule dans le tableau. y indique le nombre d'éléments que l'on veut dans le tableau. Si x est égal à "" alors chaque caractère constituera un élément du tableau. Ex: tablo1=chaine1.split(" ") les mots composant la chaine1 se trouvent dans les éléments du tablo1, les espaces ont disparus (P275).
.toLowerCase() transforme les majuscules en minuscules (P279).
.toUpperCase() transforme les minuscules en majuscules (P280).
.toString() transforme un nombre en chaîne (P280, 82). Si le nombre vaut NaN la chaîne sera "NaN".
String(x) transforme un nombre en chaîne.
.big() ajout les balises <big></big> en début et fin de chaîne. Ex: x=toto.big().
.small() ajout les balises <small></small> en début et fin de chaîne. Ex: x=toto.small().
.blink() ajout les balises <blink></blink> en début et fin de chaîne. Ex: x=toto.blink().
.bold() ajout les balises <b></b> en début et fin de chaîne. Ex: x=toto.bold().
.fixed() ajout les balises <tt></tt> en début et fin de chaîne. Ex: x=toto.fixed().
.italics() ajout les balises <i></i> en début et fin de chaîne. Ex: x=toto.italics().
.fontcolor("x") ajout les balises <font color="x"></font> en début et fin de chaîne. Ex: x=toto.fontcolor("red").
.fontsize(x) ajout les balises <font size=x></font> en début et fin de chaîne. Ex: x=toto.fontsize(7).
.strike() ajout les balises <strike></strike> en début et fin de chaîne. Ex: x=toto.strike().
.sub() ajout les balises  en début et fin de chaîne. Ex: x=toto.sub().
.sup() ajout les balises  en début et fin de chaîne. Ex: x=toto.sup().
.anchor("x") crée une cible dans un document en ajoutant les balise <a name="x"></a>. Ex: x=toto.anchor("fin"). (P262).

Les tableaux
Les tableaux en Javascript sont toujours a une dimension. Mais il est possible de faire des tableaux de tableaux, ce qui permet d'avoir plusieurs dimensions.
La déclaration des tableaux est obligatoire.
Déclaration de tableaux:titi = new Array() ou toto = new Array(5). Attention avec la version 1.2 le tableau n'a qu'un élément qui contient la valeur 5 pour les autres versions le tableau toto est déclaré avec 5 éléments (version 1.0, 1.1, 1.3).  Avec new Array(4, 2, 3) le tableau contien 3 éléments de valeur 4, 2 et 2. Si on demande la valeur de la variable toto sans préciser d'indice le résultat obtenu est une chaîne de caractères contenant tous les éléments du tableau séparer par des virgules sauf pour la version 1.2 ou des crochets encadrent les valeurs.
toto = [] permet de déclarer un tableau, toto = ["chat", false, , 123] déclare et initialise le tableau de 4 éléments. Les tableaux n'ont pas de type ou de taille définit. Les tableaux commencent toujours à zéro. L'indice d'un tableau peut avoir des décimales (a[4.5]). L'indice 4.5 ne représente pas le même élément que l'indice 4.6 . L'indice d'un tableau peut être une chaîne. Ex: tablo1["chat"]="félin", tablo1["chien"]="canidé", tablo1["vache"]=25 (P235).
La longueur d'un tableau peut être connue avec la propriété .length ex: x = toto.length. Mais cette fonction compte seulement les indices entiers. Elle se réfère en faite au dernier indice du tableau et considère que le tableau commence à l'indice 0. Les indices chaîne ne peuvent pas être comptés avec .length.
Si on définit un tableau ex: toto = new Array(), on peut de nouveau définir un tableau avec chaque élément du tableau, ex: toto[0] = new Array(). Pour accéder à chaque élément de ce tableau il faut alors utiliser la forme toto[0][0] = xxx.
Dans certain cas la définition x = new Array() est obligatoire.

Méthodes associées aux tableaux (P213)
.concat() permet de constituer un nouveau tableau à partir de plusieurs tableau. Ex: newtablo=tablo1.concat(tablo2, tablo3). newtablo contient tous les éléments de tablo1, tablo2 et tablo3.
.join() transforme un tableau en une chaîne de caractères constituer des éléments du tableau. Ex: riri=tablo1.join(). Si tablo1 contenait les valeurs 5,4,3,2 alors riri contient "5,4,3,2". La valeur dans la parenthèse de join() permet de remplacer la virgule de séparation des éléments du tableau par une chaîne de caractères. ex riri=tablo1.join("et"), maintenant riri contient "5et4et3et2". Si un élément du tableau est undefined son emplacement dans la chaîne sera vide, mais si c'est infinity ou true ce sont les chaînes "infinity" ou "true" qui apparaîtrons.
.pop() retire le dernier élément du tableau, ce qui fait que le tableau et moins long de 1 élément. Si cet élément n'est pas défini c'est undefined que l'on obtiendra. Ex: c=tablo1.pop(). Il n'y a aucune option à mettre entre les parenthèses.
.length longueur d'un tableau.
.push() ajoute un nouvel élément au tableau, ce qui fait que le tableau est plus long de 1 élément. L'élément rajouté et celui qui se trouve entre parenthèse, et si plusieurs éléments séparés par des virgules sont présents entre les parenthèses, c'est plusieurs éléments qui seront rajoutés. Ex: tablo1.push(1,"az",c).
.reverse() inverse l'ordre des éléments dans un tableau. Il n'y a aucune option à mettre entre les parenthèses. Ex: tablo1.reverse().
.shift() similaire à .pop() mais retire le premier élément du tableau. Ex: c=tablo1.shift().
.unshift() similaire à .push() mais rajoute un élément au début du tableau. Attention si on rajoute les éléments un par un ils seront dans un ordre et si on les rajoute en bloc ils seront dans le sens inverse. Ex: tablo1.unshift(1), puis(2), puis(3) ils sont dans l'ordre 3,2,1 puisque c'est toujours en première position qu'est rajouté l'élément, et que le dernier que je rajoute c'est 3, mais avec tablo1.unshift(1,2,3) les éléments seront dans l'ordre 1,2,3 puisque je les rajoute en bloc. .push() ne pose pas ce problème la puisque c'est à la fin du tableau que les éléments sont rajoutés.
.slice(x,y) retire des éléments à un tableau. x représente l'indice du premier élément retiré, y représente le premier élément conservé à la suite de x. Mais si y n'est pas présent c'est le reste du tableau qui sera retiré, si y est égal à x rien ne sera retiré, si y est négatif on compte alors à partir de la fin du tableau (-1 c'est le dernier élément qui est conservé). Ex: tablo2=tablo1.slice(2,5), les éléments 2, 3, et 4 seront retirés et affectés à tablo2.
.splice(x,y,z1,z2) retire et rajoute des éléments à un tableau. x représente le premier élément qui sera modifier, y représente le nombre d'éléments retiré au tableau, z1 et z2 représente des éléments qui seront rajoutés au tableau.
Ex: tablo2= tablo1.splice(2,3,"toto",25) tablo2 recevra les éléments d'indice 2, 3 et 4, toto prendra la place de l'élément 2, 25 prendra la place de l'élément 3, l'élément 4 n'étant pas remplacer les éléments 5 et supérieur seront décaler de 1 pour boucher le trou.
.sort() trie dans l'ordre croissant les éléments d'un tableau. Si entre les parenthèses on place l'appel d'une fonction qui renvoie 1, -1 ou 0 on peut trier dans l'ordre décroissant.

Ex:	function décroissant(a,b) { if (a > b) return -1    if (a < b) return 1    return 0 } tablo1.sort(décroissant)

.toLocaleString()
.toString()
.valueOf()

Littéraux objets(P45)
forme de tableau

Opérateur arithmétique (P46)

+	Attention si l'addition porte sur un nombre et une chaîne, c'est une concaténation qui sera effectué.  Pour les autres opérateurs le résultat sera "NAN".
-	soustraction.
*	multiplication.
/	division.
%	(modulo ou reste).
=	affectation. Ex: x=4 ou y=z+2 ou x=y=z=15 (x, y et z = 15). Attention, différent de ==.
+=	addition de lui-même. Ex: x += z équivalent à x=x+z.
-=	soustraction de lui-même. Ex: x -= z équivalent à x=x-z.
*=	multiplication de lui-même. Ex: x *=z équivalent à x=x*z.
/=	division de lui-même. Ex: x /=z équivalent à x=x/z.
++i	incrémente i avant sont utilisation, a+= ++b, b est incrémenté de 1, puis ajouté à a.
i++	incrémente i après sont utilisation, a+= b++, b est ajouté à a, puis incrémenté de 1.
--	idem mais décrémente.
-	négation(i = 8, -i égal -8).

Ex: "x[y++] += z" est équivalant à "x[y] = x[y] + z; y = y + 1" (P56).
 

&	et.
|	ou inclusif.
^	ou exclusif.
~	complément a 1.
<<	décalage a gauche sous la forme x << y, x est la variable et y est le nombre de décalage.
>>	décalage à droite.
>>>	décalage arithmétique ?

Opérateur logique, leurs résultats sont "vrais" ou "faux" (P52)

<	inférieur.
>	supérieur.
<=	inférieur ou égal.
>=	supérieur ou égal.
==	égal. Opérateur de comparaison, différent de =.
===	strictement égal. La différence entre égale et strictement égal est que le nombre 3 est égal à la chaîne "3" mais ne lui est pas strictement égal.
!=	différent.
!==	strictement différent.
&&	et.
||	ou.
!	non ou not.

 

Les fonctions (P63)
Il existe deux types de fonction dans java script, les fonctions interne à Javascript et celles qui sont définit par l'utilisateur.

Les fonctions utilisateur
Elles sont déclarées en début de script par la commande function toto1(var1,var2,...) ou au moins avant d'être utilisé. A la suite on ouvre une accolade et on place les instructions de la fonction. La fonction se termine par une fermeture d'accolade. Lorsque l'interpréteur rencontre une fonction il ne l'exécute pas. Pour que la fonction soit exécutée, il faut l'appeler. Ex: toto1() ou x=toto1(x,y) si la fonction doit retourner une valeur. Entre les parenthèses sont placé les valeurs qui sont transmises et que la fonction attend.
return x  permet de retourner une valeur (variable ou constante) à l'appel de la fonction.
Si le nombre d'argument à l'appel de la fonction n'est pas définit on peut utiliser un tableau nommé :
.arguments[] pour recevoir les valeurs. Ex: x=toto1.arguments[y] ou x=arguments[y] ?
.arguments.length permet de connaître le nombre d'arguments qui a était passer à la fonction. Ex: x=toto1.arguments.length ou x=arguments.length ? (P248).
.length donne comme résulta le nombre d'argument qu'attend la fonction toto1. Ex: x=toto1.length
.arity renvoie le nombres d'argument qu'attend une fonction. Ex: x=toto1.arity (P249).
.protptype crée un objet à partir d'une fonction utilisateur un peut particulière. La syntaxe est : type.prototype.fifi=toto1, type donne le type de l'objet (number, string,...), fifi sera le nom d'appel de l'objet. L'utilisation se fait ensuite sous la forme : variable.fifi(paramètre) ou (constant nombre).fifi(paramètre) ou "chaîne".fifi(paramètre) (P252).
arguments.callee renvoie une chaîne qui correspond aux instructions de la fonction en cour. Ex: x=arguments.callee (P247).
.caller identique à la précédente à peut de chose près (P249).
.toSource() identique à argument.callee, mais peut être utiliser n'importe ou dans le script (P255).
.toString() identique à la précédente à peut de chose près (P256).
.valueOf() identique à la précédente à peut de chose près (P257).
.apply() ? (P254).
.call() ? (P255).

Les fonctions Javascript
eval() renvoie la valeur numérique d'une chaîne si celle ci représente une valeur numérique ou renvoie NaN. Ex: eval("3*3") renvoie 9 (P77).
parseInt("10110111",2) convertie des chaînes de différente base en nombres décimaux ? Tous les caractères alphabétiques sont interdits (P78).
parseFloat("4367.37") convertie des chaînes en nombre décimal (P78).
isNaN() renvoie true si l'argument n'est pas un nombre et renvoie false si l'argument est un nombre (P80).
isFinite() renvoie true si l'argument est un nombre et false si l'argument n'est pas un nombre ou est l'infini (P80).
escape() remplace tous les caractères non imprimables et les caractères spéciaux (y comprit l'espace)par leur code ASCII en hexadécimal sous la forme "%20" (P81).
unescape() inverse de la précédente fonction.
Number() transforme une chaîne en nombre si celle ci représente un nombre sinon le nombre prend la valeur NaN et une date système en un nombre style horloge interne PC (P81).
Boolean() rend true ou false si le contenu de la parenthèse est vrai ou faux.
with() définit par défaut le chemin d'accès à un objet. Ex: with(document.toto.traitement){ document.write(value)} et équivalant à document.write(document.toto.traitement.value).

Les fonctions arithmétiques (P65, 285)
 

Math.PI	est égal à PI.
Math.E	nombre E.
Math.LN10
Math.LN2
Math.LOG10E
Math.LOG2E
Math.SQRT1_2	racine carrée de 1/2.
Math.SQRT2	racine carrée de 2.
Math.sqrt(x)	racine carrée de x.
Math.abs(x)	valeur absolue de x.
Math.cos(x)	cosinus de x en radian.
Math.acos(x)	arc cosinus de x en radian.
Math.sin(x)	sinus de x en radian.
Math.asin(x)	arc sinus de x en radian.
Math.tan(x)	tangente de x en radian.
Math.atan(x)	arc tangente de x en radian.
Math.atan2(x)	angle dont les arguments représentent, dans cet ordre, des valeurs proportionnelles respectivement au cosinus et au sinus?
Math.exp(x)	exponentiel de x.
Math.log(x)	logarithme népérien de x.
Math.random()	nombre aléatoire entre 0 inclus et 1 exclus.
Math.floor(x)	arrondit à l'entier inférieur à x.
Math.ceil(x)	arrondit à l'entier supérieur à x.
Math.round(x)	arrondit à l'entier le plus proche de x.
Math.min(x,y,z..)	donne le plus petit de x ou y ou z ou etc.
Math.max(x,y,z..)	donne le plus grand de x ou y ou z ou etc.
Math.pow(x,y)	élève à la puissance y le nombre x (P123).

Les objets (P185)
Chaque constituante d'un navigateur est un objet lui même constitué d'autres objets. Par exemple l'objet navigator, qui représente le navigateur, est constitué d'un objet document, qui représente le document html, lui-même constitué d'autre objet comme son titre ou la couleur des liens. Les objets peuvent être en lecture seuls ou en écriture seul ou en lecture et écriture. document.write() est en écriture seul, document.LastModified est en lecture seul.
Script permettant de visualiser les objets attachés à un objet. Attention ce script peut ne pas fonctionner sur certain navigateur ou pour certains objet.
<script language = "javascript">
<!--Masque du script
function proprietes(object, nom)
 {var texte = ""
   for (var i in object)
      texte += nom + "." + i + " = " + object[i] + "<br>";
   return texte;
 }
document.write("<hr>Propriétés  : <br>" + proprietes(document, "document") + "<hr>")
// Fin du script -->
</script>

L'objet document
document.write() affichage dans le document Html a la norme Html (balise).
.alinkColor="x" définit la couleur des liens. Ex: document.alinkColor="red".
.linkColor="x" définit la couleur des liens sélectionnés. Ex: document.linkColor="#FF0000".
.vlinkColor="x" définit la couleur des liens visités. Ex: document.vlinkColor="red".
.bgColor="x" définit la couleur de fond du document. Ex: document.bgColor="#00FFFF".
.fgColor="x" définit la couleur de texte du document. Ex: document.fgColorr="black".
.LastModified renvoie la date d'enregistrement du document sur le disque. Ex: document.write(document.LastModified)
.documentElement.clientWidth ou Height taille de la fenêtre du navigateur pour IE6 ???
.body.clientWidth ou Height taille de la fenêtre du navigateur pour IE 6 et du navigateur pour IE4

Sélection d'objets
document. envoie ou reçois une commande du document en cour (zaza.document. ferait référence à un document nommé zaza). Les composants d'une page web (notre document) sont rassemblés dans des tableaux. On peut donc accéder à tous les objets affichés en se servant d'un de ces tableaux (en fonction de l'objet) correctement indexé. Les objets sont indexés dans l'ordre de leur apparition de 0 à x.
.images[x] liste des images affichées sur la page. Dans images on va modifier l'objet src. Ex: document.images[0].src="adr.gif" modifie l'image affichée. On ne peut pas modifier sa taille.
.links[x] liste des liens sur la page. Dans links on va modifier l'objet href. Ex: document.links[1].href="adresse" modifie l'adresse vers la quel point le lien.
.layers[x]
.forms[x]
.elements[y] sous objet de forms[x] ex: x=document.forms[3].elements[5].value

On peut aussi envoyer ou recevoir des donnés dans des zones du document en les appelant par leur nom. Ex: dans la section <form name=tata>, <select name=riri> pour recevoir la valeur de l'index sélectionné il faut rentré la commande x =document.tata.riri. selectedIndex. Si le formulaire se trouve sur un autre document nommé fifi alors x =fifi.document.tata.riri.selectedIndex.

Les propriétés des images (P467)
.border donne l'épaisseur de la bordure d'une image. Ex: x=document.images[y].border.
.complete renvoie true si l'image est complètement chargée.
.height donne la hauteur de l'image en pixel.
.width donne la largeur de l'image en pixel.
.hspace donne, en pixel, l'espace horizontal entourant l'image tel qu'il a était définit par la balise <hspace>.
.vspace identique à .hspace mais vertical.
.lowscr donne l'adresse de l'image basse résolution, si elle existe.
.name donne le nom de l'image.
.src donne l'adresse de l'image ou permet de modifier une image (uniquement l'image pas les autres attributs). Ex: x=document. images[y].scr, document.images[y].scr=x

Trois évènements sont lié aux images:
onAbort abandon du chargement de l'image.
onError erreur pendant le chargement de l'image.
onLoad fin du chargement de l'image.

Les images réactive
(P490)

Les images XBM (P724)
Ce sont des images binaire en noir et blanc constitué d'une suit d'octés définissant l'image. Elles ce trouvent dans une balise <img src="javascript:'#define x 16 \n#define y 20 \n static unsigned char c[]={0xff, 0xab, 0x00,…}'">. 16 représente le nombre de bit horizontal (par paquet de 8 en général), 20 le nombre de lignes vertical, et 0x.. les octés qui définissent l'image (dans notre exemple il y a 40 octés à définir). Les bits sont comptés de gauche pour le poids faible à droite pour le poids fort, et les octés de gauche à droite et de haut en bas.

Condition de traitement (P94)
if (argument comparaison argument)
{début traitement si comparaison vraie
fin de traitement }
else
{début traitement si comparaison fausse
fin de traitement }

a = b < c ? d - 2 : d + 2 est égal à: si b<c alors a=d-2 sinon a=d+2. Ex: document.write(heure < 12 ? " matin ":"après midi","<BR>") (P56).

L'instruction switch permet de tester une expression, placée entre parenthèse, à des constantes chaîne ou numérique ou à une propriété système (document.forms.length). L'ensemble des testes se trouvent entre des accolades après l'instruction switch. Chaque teste commence par l'instruction case, suivi de la constante de référence, d'un double points et des instructions à exécuter si la comparaison est vraie. A la fin des instructions on peut trouver une instruction break qui indique que le traitement est fini, sinon les instructions s'arrêtent à la fermeture de l'accolade. Une seule instruction case sera testé vrai et exécuté les autres même si elles sont vrai seront ignorées. L'instruction default, qui se trouve parmi les instructions case, est réalisée si aucune des instructions case ne sont vrai (P101).
 

exemple:

switch (expression) {case  constante : instruction    instruction suite    break  case constante : instruction ; break  default : instruction ; break}

Instructions de boucle (P108)
Boucle for. Elle se compose de l'instruction for suivi, entre parenthèses, de l'expression de départ de la variable, d'un point virgule, du test de fin de boucle, d'un point virgule, est d'une expression régissant l'incrément de la variable. Attention si le test de fin de boucle ne peut se réaliser vrai la boucle se répètera à l'infini. Après l'instruction for une paire d'accolades définit les instructions de la boucle. On peut déclarer plusieurs variable en même temps, séparer par des virgules, dans la zone expression de départ y compris avec la commende var, ce qui fait que la variable devient une variable locale. Le teste de fin de boucle peut ne pas avoir de rapport avec la variable "de control".
exemple:
for (a = 5; a > 1; a--) ou for (a= 0; a <= 10; a = a + 0.1) ou for (var a= 0, b=1; a < 10 && c < 14 ; a++, b += 2)
{ instructions de la boucle }

for (x in toto), toto est un tableau définit, la variable x va prendre succéssivement toutes les valeurs de l'indice du tableau toto.(1.5P114)

Boucle while. Elle se compose de l'instruction while suivi de, entre parenthèses, la condition de control qui dé qu'elle sera fausse arrêtera la boucle. En suite entre des accolades viennent les instructions de la boucle.

exemple:

while (a > b) { instructions de la boucle }

Boucle do while. Elle se compose de l'instruction do suivi, entre accolades, des instructions de la boucle puis de l'instruction while sur le même format que précédemment. La différence entre ces deux instructions et que while évalue la condition et exécute les instructions si la condition est vrai alors que do while exécute les instructions d'abord puis évalue la condition et si elle est vrai recommence la boucle (P119).

L'instruction Break placé dans une boucle arrête la boucle et quitte l'iteration.
L'instruction Break suivit d'un label quitte la boucle et revoi au label (P121).
L'instruction continue placée dans une boucle for ou while permet d'ignorer la suite des instructions et de retourner directement en début de boucle pour l'itération suivante.

Les boites de message (P139)
alert() affiche une boite avec le contenu de la parenthèse et un bouton OK qui permet de valider la boite. Elle ne renvoi aucune valeur. Le format d'affichage et le format de Windows et non celui du Html. Entre les parenthèses peuvent se trouver une constante, une variable, une chaîne, une expression de variables de chaîne ou de constantes, mais une seul chose à la fois (P140).
confirm() identique à alert() mais possède 2 boutons qui renvoie true si on clique sur OK et false si on clique sur annuler (P141).
prompt(x, y) cette instruction affiche une boite de dialogue avec comme titre "x" ou le contenu de x (chaîne ou numérique) et qui attend une valeur (chaîne ou numérique). Elle renvoie cette valeur si on clique sur OK(ou tape sur return) ou renvoie null si on clique sur annuler (I.Explorer ne rende rien du tout). y est une valeur qui sera proposer par défaut. Si la valeur par défaut n'est pas présente c'est undefined qui est proposer dans la boite. x et y peuvent être une chaîne(entre guillemets), une constante numérique, une variable chaîne ou une variable numérique. x peut contenir \n pour le passage à la ligne. Si x est plus grand que ce que peut afficher la boite de dialogue il sera tronqué en longueur et/ou en hauteur (P143).
status affiche un message dans le bas de la fenêtre du navigateur. Attention le navigateur utilisant lui-même cette zone il se peut que l'affichage soit remplacer par les messages du navigateur. Ex: setTimeout("status='fin de tempo', 5000). Dans certain cas il faut faire suivre cette instruction de "; return true" pour que sa fonctionne. Ex: onmouseover="status='souris dessus'; return true"

Les évènements (P159,763)
Il existe plusieurs type d'évènement dans Javascript, les événements automatiques lier à un temporisateur, les événements lier à une balise Html (chargement d'un document, clique sur des boutons ou formulaires) et les évènements généraux dus aux actions de l'utilisateur ( mouvements de la souris, appuie sur des touches).

Les temporisateurs
Les temporisateurs n'arrêtent en aucun cas le déroulement du script. Lorsque le script rencontre un temporisateur il déclenche le comptage du temps et pendant ce temps il continue le script. Lorsque le temps est terminé, il exécute les instructions contenues dans le temporisateur. Ces instructions peuvent être de n'importe quelle nature y compris l'appel d'une fonction. Attention si le délai du temporisateur est trop court le script n'a plus le temps de se finir entre deux intervalles du temporisateur cela peut générer des erreurs dans le script ou de la part de la console java.
setInterval(x,y) évènement qui se réalise toutes les y millisecondes et qui appel la fonction x. Ex: setInterval("moteur(x)",1000), appel la fonction moteur() toutes les secondes. On peut donner un nom a à cet événement sous la forme toto=setInterval("fifi()",500), toto est le nom de ce temporisateur. On peut avoir plusieurs temporisateurs dans un même document. (P441).
clearInterval(x) arrête la répétition de l'évènement setInterval() de nom x. Ex: clearInterval(toto).
setTimeout(x,y) évènement qui se réalisera au bout de y millisecondes mais qui ne se réalisera qu'une fois ce qui le différencie de setInterval(). Ex: setTimeout("fifi(x)",200) ou riri=setTimeout("fifi()".3000). (P445).
clearTimeout(x) arrête le temporisateur setTimeout(), l'instruction qu'il contient ne sera pas réalisée. Ex: clearTimeout(riri).

Les événements lier à une balise Html (P164)
Ces évènements ne se trouve pas dans le script mais dans le document Html à l'intérieur d'une balise.
onLoad=fct() placé dans la balise <body> cette évènement se produit lorsque le document Html est chargé, script fini (sauf pour les temporisateurs qui peuvent continuer temps que le document est affiché). Ex: <body onLoad=toto()>.
onUnload=fct() placé dans la balise <body> cette évènement se produit lorsque l'on quitte le document Html. Ex: <body onUnload=titi()>.
onClick=fct() placé dans une balise <input> de type="button", cette évènement se produit lorsque l'on clique sur le boutton en question. Ex: <input type="button" onClick=toto()>
onMouseOver placer dans une balise <a> ces événements ce produisent quand la souris se trouve ou
onMouseOut quitte le lien désigné par <a>.

exemple d'évènement lié à une balise

<a href="javascript:viod(0)"    onMouseOver=document.images[0].src="foto1.jpg"    onMouseOut=document.images[0].src="foto2.jpg"> <img src="foto2.jpg"> </A>

Les évènements généraux (P763)
Les évènements généraux, pour Netscape, sont traité en deux parties. Premièrement il faut indiquer au navigateur les évènements susceptibles de nous intéresser, puis il faut indiquer au navigateur le type de traitement lier à ces évènements.
La prise en charge de l'évènement se fait par l'instruction captureEvents(). Cette instruction doit être lier à l'objet dans lequel l'évènement doit se produire (window ou document)  et entre parenthèse on précise le type d'événement qui nous intéresse. S'il y a plusieurs évènements ils sont séparer par un | (ou). Ex: window.captureEvents( Event.MOUSEMOVE | Event.MOUSEOVER ). Si on ne précise pas window ou document c'est l'objet window qui sera pris par défaut. Ex: captureEvents(Event.MOUSEMOUVE). Attention si on précise document il faut que pour la suite il soit fait référence à l'objet document. Cette instrution n'est pas reconnu par I.E.

Une fois la déclaration de l'événement faite, on indique le traitement apporté à cet événement. Ex: window.onMouseMove=toto indique le traitement à apporter à l'événement Event.MOUSEMOVE. toto est une fonction qui a été définit précédemment, elle n'est pas suivit de parenthèse exceptionnellement.
Pour I.Explorer les événements sont liés à une balise HTML, ou lier à l'objet document. On utilise donc pas la prise en charge de l'événement comme dans Netscape. Les événements sont les mêmes que pour Netscape. Ex: <body onmousemove="toto()" onmousedown=titi()> ou document.onmousemove=toto.

Objet de la fonction event pour Netscape (P764).
Ces objets renseignent sur les paramètres de l'événement (position de la souris, touche enfoncée, objet dans lequel se trouve la souris). Ils sont liés à l'argument de la fonction qui a été appelé par l'événement. Si l'événement appel la fonction toto(), dans la déclaration de la fonction on a écrit function toto(riri), on obtient le nom de la touche enfoncé par x=riri.which.

.data uniquement pour ondragdrop donne la liste des URL des objets que l'on a fait glisser.
.height hauteur de l'objet redimensionné.
.width largeur de l'objet redimensionné.
.layerX
.layerY
.modifiers
.pageX position horizontale du curseur par rapport au document.
.pageY position verticale du curseur par rapport au document.
.screenX position horizontale du curseur par rapport à l'écran.
.screenY position verticale du curseur par rapport à l'écran.
.target donne le nom de l'objet à l'intérieur du quel c'est produit l'événement (window, document, layer).
.type donne le nom de l'événement qui vient de se produire.
.which donne le nom de la touche ou du bouton de souris qui a produit l'événement. Attention le résultat obtenu change entre I.Explorer et Netscape (P768).
.x égal à pageX sauf si  événement onResize alors égal à layerX (Largeur du document) (P770).
.y égal à pageY sauf si  événement onResize alors égal à layerY (Hauteur du document) (P770).

Objet de la fonction event pour I.Explorer (P781).
Il n'y a pas d'argument à la fonction pour I.E., et c'est l'objet event qui est utiliser. Ex: Function toto() {y=event.clientX}

.altKey la touche alt a été enfoncée.
.ctrlKey  la touche ctrl a été enfoncée.
.shiftKey la touche shift a été enfoncée.
.keyCode code de la touche enfoncée.
.button un bouton de la souris a été enfoncé.
.type type de l'événement.
.cancelBubble arrête la cascade des événements.
.clientX abscisse de l'événement par rapport à la fenêtre.
.clientY  ordonnée de l'événement par rapport à la fenêtre.
.offsetX  abscisse de l'événement par rapport au document.
.offsetY  ordonnée de l'événement par rapport au document.
.screenX  abscisse de l'événement par rapport à l'écran.
.screenY  ordonnée de l'événement par rapport à l'écran.
.x  abscisse de l'événement par rapport à la fenêtre.
.y  ordonnée de l'événement par rapport à la fenêtre.
.fromElement élément que la souris vient de quitter.
.toElement élément dans lequel la souris vient d'entrer.
.reason statut pour les événements de transfert de données.
.returnValue valeur de retour du gestionnaire d'événement.
.srcElement élément ayant causé l'événement.
.srcFilter ?

 

Exemple pour Netscape	Exemple pour I.Explorer
function toto(riri) {x=riri.pageX; y=riri.pageY} function tata(fifi) {z=fifi.target} window.captureEvents( Event.MOUSEMOVE  | Event.MOUSEOVER ) window.onMouseMove=toto window.onMouseOver=tata	function toto() {x=event.clientX; y=event.clientY} function tata() {z=event.srcElement} <body onMouseMove=toto()  onMouseOver=tata()> ou document.onmousemove=toto document.onmouseover=tata

onevenement= appel une fonction ou des instructions a la suite d'un évènement. Les instructions sont une suite de commande sous forme de chaîne. les instructions sont séparer par des points virgule. Ex: onevenement="var= 0; compt++; calculer();"
onClick=fontion(this.name) appel la fonction lorsque l'on clique. this.name renvoie le nom de se sur quoi on a cliqué.
this.xxx renvoie une valeur correspondant à la propriété xxx de ce sur quoi on clique. Ex: this.value renvoie la valeur de l'élément cliquer si celui ci en a une.

Les dates (P403)
Les mois sont toujours comptés de 0 pour janvier à 11 pour décembre. Les jours sont toujours compté de 0 pour dimanche à 6 pour samedi.

new Date() renvoie la date du PC au format: "nom-jour  nom-mois  quantieme-jour  hh:mm:ss  ref.utc aaaa" mais si entre les parenthèse on a placer une date au format (aaaa,MM,jj,hh,mm,ss,ms) alors c'est cette date qui sera affecté à la variable. Ex: dat1=nex Date(1957,5,11).
.getTime() extrait le nombre de millisecondes depuis le 1 1 1970. Ex: heure= dat1.getTime().
.getTimezoneOffset() extrait le décalage en minute par rapport au méridien de Greenwich.
.getDay() extrait un chiffre correspondant au jour de la semaine de 0 pour dimanche à 6 pour samedi. Ex: njour=dat1.getDay().
.getUTCDay() identique à .getDay().
.getDate() extrait le quantième de jour. Ex: jour=dat1.getDate().
.getUTCDate() identique à .getDate().
.getMonth() extrait le mois de 0 pour janvier à 11 pour décembre.
.getUTCMonth() identique à .getMonth().
.getYear() extrait l'année sur 2 chiffres avant 2000 et sur 3 chiffres à partir de 2000. Ex: 2003 et égal à 103.
.getFullYear() extrait l'année sur 4chiffres. Ex: aaaa=dat1.gatFullYear().
.getUTCFullYear() identique à .getFullYear().
.getHours() extrait l'heure.
.getUTCHours() identique à .getHours().
.getMinutes() extrait les minutes.
.getSeconds() extrait les secondes.
.getMilliseconds() extrait les millièmes de secondes.
.getUTCMilliseconds() identique à .getMilliseconds().

Dans toutes les commandes .set qui suivent ce n'est jamais une addition qui est faite mais un remplacement de la valeur correspondante. Si la valeur mise en place ne correspond pas à une valeur possible il y a correction des autres valeurs pour obtenir une date cohérente. Ex: si on rentre 35 jours à un mois qui ne peut en avoir que 31 alors le jour sera égal à 4 et le mois augmenté de 1 et si le mois etait égal à 11 (avant l'augmentation) alors il passe à 0 et l'année est augmenté de 1 (P415).

.setTime(x) affecte une date à partir d'une valeur en milliseconds. 0 correspond au 1 janvier 1970 à 1h 0m 0s.
.setDate(x) modifie le nombre de jours dans une variable new Date. La valeur x est mise à la place du nombre de jours de la date. Si x est supérieur au nombre de jour du mois en cour ou si x est inférieur à 1 l'ensemble de la date sera modifier pour obtenir une date cohérente. Ex: dat1.setDate(3).
.setUTCDate() identique .setDate().
.setMonth(x) modifie le mois dans une date. Si x est supérieur à 11 ou inférieur à 0 il y a répercussion sur le reste de la date. Ex: dat1.setMonth(7).
.setUTCMonth(x) Identique a .setMonth().
.setFullYear(x) modifie l'année dans une date. x peut être sous la forme 1995,5,11 c'est alors l'année le mois et le jour qui sont modifier. Les mêmes conditions que pour .setSate() s'applique au mois est au jour. Ex: dat1.setFullYear(1995,12,33) donne comme date le 2 février 1996.
.setUTCFullYear(x) Identique a .setUTCFullYear().
.setHours(x) modifie les heures dans une date. Si x est supérieur à 23 ou inférieur à 0 il y a répercussion sur le reste de la date. Ex: dat1.setHours(10).
.setUTCHours(x) Identique a .setHours().
.setMinutes(x) modifie les minutes dans une date. Si x est supérieur à 59 ou inférieur à 0 il y a répercussion sur le reste de la date. Ex: dat1.setMinutes(25).
.setUTCMinutes(x) Identique a .setMinutes().
.setSeconds(x) modifie les seconds dans une date. Si x est supérieur à 59 ou inférieur à 0 il y a répercussion sur le reste de la date. Ex: dat1.setSeconds(25).
.setUTCSeconds(x) Identique a .setSeconds().
.setMilliseconds(x) modifie le nombre de millisecondes dans une date. x va de 0 à 999, au-delà il y a répercussion sur le reste de la date (ajouter 1000 revient à ajouter 1 seconde). Ex: dat1.setMilliseconds(50).
.setUTCMilliseconds(x) Identique a .setMilliseconds().

Date.parse(x) renvoie le nombre de millisecondes écoulé entre 1 1 1970 et la date représentée par x. Ex: x=Date.parse(dat1).
Date.UTC(x) renvoie le nombre de millisecondes écoulé entre le 1 1 1970 et la date entrée sous le format (1999,7,23,12,35,59). Ex: x=DateUTC(1999,7,23,12,35,59).
.toLocalString() transforme la date en une chaîne selon le format de date local du PC. Ex: x=dat1.toLocalString.
.toUTCString() décale l'heure locale en heure GMT. Ex: x=dat1.toUTCString(), si on est le 10 août 1999 à 8h 25m 12s la date rendue sera le 10 août 1999 6h 25m 12s à cause de l'heure d'été.

Liste des options d'un objet
Ce petit script permet de visualiser les options d'un objet.
<script language="javascript">
function proprietes(object,nom)
 {var texte = ""
  for (var i in object)
     texte += nom + "." + i + " = " + object[i] + "<br>";
  return texte;}
document.write("<hr>Propriétés  : <br>" + proprietes(navigator, "navigateur") + "<hr>")
</script>
Dans le script le nom en violet est l'objet étudié, et le nom en violet entre guillemet et le nom de l'objet dans l'affichage. Les options d'un objet varient en fonction du navigateur utiliser.

L'objet navigator(P501)
Cet objet renseigne sur le navigateur utiliser. Il est utiliser sous la forme x=navigator.objet.
.appCodeName nom de code du navigateur donné par sont éditeur.
.appName nom du navigateur.
.appVersion version du navigateur.
.language langue du navigateur.
.mimeTypes[] tableau des types mime reconnu.
.platform type de machine reconnu par le navigateur(Win32 Win16 Mac68k MacPPC aix hpux sunos ultrix et cætera).
.plugins tableau des plugins installé.
.securityPolicy règle de sécurité à appliquer.
.userAgent ?
.cookieEnabled true ou false I.E. seulement.
.cpuClass type de CPU I.E. seulement.
.onLine true ou false I.E. seulement.
.javaEnabled() true ou false console java active. Question si la console java n'est pas active comment cet objet pourrait-il avoir une réponse?

L'objet screen (P689)
Cet objet renseigne sur l'écran de l'ordinateur. Il ne peut être que lu.
.availHeight hauteur libre de l'écran pour l'affichage.
.availWidth largeur libre de l'écran pour l'affichage.
.heigth hauteur de l'écran.
.width largeur de l'écran.
.availLeft objet Netscape sans information.
.availTop objet Netscape sans information.
.colorDepth nombre de bit de couleur de l'affichage.
.pixelDepth nombre de bit de couleur de l'affichage. Objet spécial Netscape.
.bufferDepth objet I.E. sans information.
.pdateInterval objet I.E. sans information.

L'objet window (P297)
Cet objet concerne la surface d'affichage du navigateur. Il peut être lu ou modifié pour certain objet. La présentation diffère pour Netscape et I.Explorer. L'objet window étant le premier objet du navigateur il n'est pas obligatoire de le préciser pour y faire référence. On peut aussi faire référence à l'objet windows avec l'objet "self".
Ex: window.closed, closed ou self.closed sont équivalents.

Netscape	I.Explorer
.closed	.closed	rend true si la fenêtre est fermée. Ex: x=toto.window.closed.
.defaultStatus	.defaultStatus	valeur affichée par défaut dans le bas du navigateur.
.status	.status	valeur affiché dans le bas du navigateur.
.document	.document	sous objet de l'objet window.
.frames	.frames	sous objet de l'objet window.
.history	.history	?
.innerHeight	utiliser l'object   document	hauteur de la fenêtre d'affichage du navigateur.
.innerWidth		largeur de la fenêtre d'affichage du navigateur.
.outerHeight		hauteur du navigateur.
.outerWidth		largeur du navigateur.
.pageXoffset		position horizontale de la fenêtre par rapport au document.
.pageYoffset		position verticale de la fenêtre par rapport au document.
.length	.length	nombre de frame dans la fenêtre principale.
.location	.location	URL de la page affichée.
.location.href="	.location.href="	Envoi le navigateur à l'adresse indiquée.
.locationbar		barre dans la quelle apparais l'URL, vaut true si elle est visible.
.menubar		barre des menus du navigateur, et vaut true si elle est visible.
.personalbar		barre personnelle du navigateur, et vaut true si elle est visible.
.scrollbar		barres de défilement du document, et vaut true si elles sont visibles.
.name	.name	nom de la fenêtre du navigateur.
self	self	fait référence a la fenêtre en cour et remplace window. Ex: self.document.write est équivalant à window.document. write.
.opener	.opener	nom de la fenêtre qui a générée la fenêtre en cour lorsqu'il y a plusieurs fenêtres.
.parent	.parent	nom du document <frameset>.
.back()	.back()	équivaut à cliquer sur précédent. Ex: window.back().
.forward()	.forward()	équivaut à cliquer sur suivant.
.home()		équivaut à cliquer sur home.
.blur()	.blur()	fait perdre le focus a la fenêtre.
.focus()	.focus()	donne le focus à une fenêtre.
.captureEvents(x)		voir gestion des évènements généraux.
.disableExternalCapture()
.enableExternalCapture()
.routeEvent()
.handleEvent()
.releaseEvents()
.moveBy(x,y)	.moveBy(x,y)	déplace la fenêtre de x pixels horizontalement et de y pixels verticalement. Déplacement relatif.
.moveTo(x,y)	.moveTo(x,y)	place la fenêtre à x pixels horizontalement et à y pixels verticalement. Déplacement absolu.
.resizeBy(x,y)	.resizeBy(x,y)	modification de la taille de la fenêtre par le coin inférieur droit. Taille relative.
.resizeTo(x,y)	.resizeTo(x,y)	modification de la position du coin inférieur droit de la fenêtre. Taille absolu.
.scrollBy(x,y)	.scrollBy(x,y)	déplacement des ascenseurs en relatif. x horizontal, y vertical.
.scrollTo(x,y)	.scrollTo(x,y)	déplacement des ascenseurs en absolu.
.find(x,y)	.find(x,y)	recherche une chaîne dans le document, x est la chaîne recherchée, y sont des options de recherche. (P322)
	.navigate(x)	envoie le navigateur à l'adresse x.
.print()	.print()	imprime le document.
open("","","x")	open("","","x")	ouvre une fenêtre. Les deux chaînes vide ou non sont obligatoires, x représente des para-
mètres. Attention tous les paramètres ne sont pas reconnus par I.E. Ex: toto = open("url", "nom", "innerHeight=500, innerWidth =350, screenX=400, screenY=10, scrollbars=1, resizable=1"), ouvre une nouvelle fenêtre nommée toto, dont la taille est 350*500, ou les bars de défilement et la modification de taille de la fenêtre sont autorisés et qui se trouve à 400 du bord gauche et à 10 du bord du haut. Si "url" est une chaîne vide la fenêtre sera vide , si "nom" est une chaîne vide c'est sans importance. (P329)
.close()	.close()	ferme une fenêtre, ce n'est pas l'objet window qui utilise cette fonction mais le nom de la fenêtre à fermer. Ex: toto.close().
.stop()	.stop()	arrête le chargement en cour, ce n'est pas l'objet window qui utilise cette fonction mais le nom de la fenêtre à fermer. Ex: toto.stop().

Import Export (P729)
Ces deux instructions sont utilisées dans des frames pour permettre à une fonction définit dans un cadre d'être utilisée à partir d'un autre cadre.

Ex:	export riri exporte la fonction riri(), la fonction n'est pas suivie de parenthèse. import top.x.* importe tous les objets (*) exporté par le cadre de nom x.

Expressions régulières (P732)
permet, entre autres, de remplacer dans un texte une chaîne par une autre comme le fait la fonction "remplacer" dans un traitement de texte.

Les layers
Pour netscape 4.x
on peut modifier les différents éléments d'un layer par la commende document.layer[x].option=y. x représente un index dans l'ordre des layer ou le nom donné au layer (par l'option name=), y représente la nouvelle valeur de l'option et option représente une fonction top, left, widht, etc... du layer.

Pour I.E.
On utilise la commende document.all[x].style.option=y. x, y et option on les même représentation que pour netscape 4x. attention: si on utilise un index, et comme la commende all représente tous les éléments du document, l'ajout d'une balise décale l'index de 1.

Pour netscape 6x et 7x
on utilise la commende document.getElementById(x).style.option=y.x, y et option on les même représentation que pour netscape 4x

Dans les trois cas on peut utiliser le nom du layer comme index. Exemple: toto1, toto2 équivalent à "toto" + 1, "toto" + 2

Quel navigateur est utilisé
<script>
xxx=0 //par défaut
if (document.layers)  {xxx=1}// si on utilise des layer
if (document.all) {xxx=2} // si c'est I.E.
if (document.getElementById&&!document.all) {xxx=3}//si c'est netscape 6x ou 7x
</script>
Dans l'exemple ci-dessus, xxx= 1 si c'est netscape 4x, xxx=2 si c'est I.E., xxx=3 si c'est netscape 6x ou 7x. Si le navigateur ne prend pas en charge une des 3 représentation xxx=0.

Divers
Unicode système de codification des caractères sur 16 bits encore peut utiliser.
void() Page 488