docFermetures (portée des variables)
download 
Plainte Transcription
Fermetures (portée des variables)
Fermetures (portée des variables)
< s c r i p t type =" t e x t / j a v a s c r i p t " >
f u n c t i o n a j o u t e u r ( nombre ) {
funct i on ajoute ( valeur ) {
r e t u r n v a l e u r + nombre ;
}
return ajoute ;
}
var aj out e 10 = a j o u t e u r ( 1 0 ) ;
aj oute10 ( 1 ) ; / / r e t o u r n e 11
</ s c r i p t >
la fonction interne ajoute10 a toujours accès au paramètre effectif
nombre malgré le fait que l’appel à la fonction ajouteur soit terminé.
Arnaud RENARD (URCA)
DHTML
[email protected]
15 / 75
Format de structure de données
JSON
Object
Notation)
Utilise(JavaScript
la syntaxe des
objets
JavaScript
{"menu":
{"id": "file",
"value": "File"
"popup": {"item": [ {"value": "New" },
{"value": "Open"},
{"value": "Close"}] }}}
<menu id="file"
<popup>
<item
<item
<item
</popup>
</menu>
value="File">
value="New" />
value="Open" />
value="Close" />
Équivalent XML
http://www.json.org/
Deux structures :
Objet
{}
JSON {chaîne
(JavaScript
Object Notation)
: valeur}
{chaîne : valeur, chaîne : valeur,
…}
Tableau
[]
[valeur]
[valeur, valeur, …]
Valeur :
chaîne|nombre|objet|tableau|true|false|null
Fonctions anonymes
< s c r i p t type =" t e x t / j a v a s c r i p t " >
var maFonction = f u n c t i o n ( message) {
a l e r t ( message ) ;
};
/ / a f f i c h e : c e c i es t un t e s t
maFonction ( ’ c e c i es t un t e s t ’ ) ;
</ s c r i p t >
<html >
<body onload =" setTim eout ( f u n c t i o n ( ) {
a l e r t ( ’ chargement de l a page term iné ’ )
} , 1500 ) ; " >
</ body>
</ html >
Arnaud RENARD (URCA)
DHTML
[email protected]
18 / 75
fonctions / Object à prototype
< s c r i p t>
function
this
this
this
Cd ( p_chanteuse , p _ t i t r e ) {
. chanteuse=p_chanteuse ;
. t i t r e =p_titre ;
. description = function ( ) {
r e t u r n t h i s . t i t r e +" par "+ t h i s . chanteuse ;
}
t h i s . laChanteuse = af f ic heChanteus e ;
}
f u n c t i o n af f ic h eChanteus e ( ) {
a l e r t ( t h i s . chanteuse ) ;
}
mycd = new Cd ( " Madonna " , " Frozen " ) ;
a l e r t ( mycd . t i t r e ) ; / / Frozen
a l e r t ( mycd . d e s c r i p t i o n ( ) ) ; / / Frozen par Madonna
mycd . laChanteuse ( ) ; / / Madonna
Arnaud RENARD (URCA)
DHTML
[email protected]
19 / 75
fonctions / Object à prototype
Cd.prototype.updateTitre=function(newTitre){
this.titre = newTitre;
}
• On ajoute ainsi une méthode dans le prototype,
toutes les instances y ont donc accès.
• Possibilité d’ajouter la méthode dans un autre fichier.
• Attention, prototype est aussi une bibliothèque js.
• Des limitation sur les objets pré-existants (Date,
Array, String, …)
Arnaud RENARD (URCA)
DHTML
[email protected]
20 / 75
Héritage -like
function Animal(nb_pattes) {
this.pattes = nb_pattes ;
this.dormir = function() { return "ZZZzzz..." ; }
};
Oiso.prototype = new Animal(2) ;
function Oiso() { } ;
Chien.prototype = new Animal(4) ;
function Chien() { } ;
var titi = new Oiso() ;
var grosminet = new Chien() ;
window.alert("Grosminet a " + grosminet.pattes + " pattes") ;
window.alert("Grosminet, au lit ! " + grosminet.dormir() + "") ;
window.alert("Titi a " + titi.pattes + " pattes") ;
Introspection
alert(mycd); // object [Object]
mycd.debug(); // todo !
Introspection
// Testons si cette méthode n'existe pas déjà !
if (!Object.prototype.debug) { // le type natif est Object
// Créons la méthode
Object.prototype.debug = function() {
var text = 'Object {\n';
for (var i in this) {
text += ' [' + i + '] => ' + this[i] + '\n';
}
alert(text + '}');
}
}
Introspection
// Testons si cette méthode n'existe pas déjà !
if (!Object.prototype.debug) { // le type natif est Object
// Créons la méthode
Object.prototype.debug = function() {
var text = 'Object {\n';
for (var i in this) {
if (i !== 'debug') {
text += ' [' + i + '] => ' + this[i] + '\n';
}
}
alert(text + '}');
}
}
JavaScript est un langage orienté objet à base d’instances et
non à base de classes (POO orientée prototype)
Une instance peut être
construite
Développement
orienté
objetà partir d’une fonction
constructeur
this est initialisé par le constructeur pour faire référence à
l’instance courante
L’héritage dans la programmation objet orientée prototype
se fait à base de clonage
L’instance est composée de slots de données (les fonctions
sont des données !)
