JAVASCRIPT

JAVASCRIPT
TELECOM PARISTECH
Slides préparés par Jean-Claude Dufourd et Cyril Concolato.
0
JAVASCRIPT
Ŷ Historique
Ŷ Bases
• Syntaxe de base, variables, fonctions, expressions, boucles, conditions
Ŷ Programmation « avancée »
• Object, Array et autres objets globaux
• Function, arguments, call, apply, map
Ŷ Particularités importantes:
• closure,…
Ŷ Programmation Orientée Objet:
• constructeur, héritage, surcharge,…
Ŷ Environnements (navigateur, node.js, JSON)
HISTORIQUE
Ŷ Langage de programmation créé par Brendan Eich, Netscape, en 1994/1995
• En quelques semaines
• Au plus fort de la bataille avec Microsoft ("browsers war", JScript)
• D'abord nommé Mocha, puis LiveScript, puis JavaScript,
• Appelé JavaScript pour apaiser une dispute avec Sun, en référence au langage Java
- Mais très différent de Java: ne pas confondre!
Ŷ Standardisé sous le nom ECMA-262, ECMAScript…
• 1ère version (1997)
• 3e édition (1999)
• 5e édition - ES5 (2009)
• 6e édition - ES6 (2015)
• 7e édition - en cours
PARTICULARITÉS DU LANGAGE
Ŷ Langage interprété (côté client)
Ŷ Inspiré des langages Scheme et Self (et Java pour la syntaxe)
Ŷ Très puissant, mais avec des erreurs de jeunesse dignes d'une béta
Ŷ Vidéos: The Good Parts par Douglas Crockford
SYNTAXE DE BASE
Ŷ Syntaxe inspirée du C, du Java
• Utilisation de {} pour séparer les blocs de code
• Utilisation de () pour les fonctions, les if, ...
• Commentaires
- Sur une ligne avec ŵŵ
- Sur plusieurs ligne avec ŵƋƋŵ
• Sensibilité à la casse: une variable ƒ est différente de Ŷ Quelques particularités:
• L'utilisation de ; après chaque expression n'est pas obligatoire, mais fortement conseillé!
ƒ
ʰ
ɪ
‘•‘Ž‡ŜŽ‘‰ſƒƀ
équivalent à
ƒʰɪŚ
‘•‘Ž‡ŜŽ‘‰ſƒƀŚ
LES BASES PAR L’EXEMPLE: LES VARIABLES
Ŷ déclarer une variable
˜ƒ”šŚ
• On ne déclare pas le type d'une variable
• La valeur initiale, par défaut est la valeur spéciale: —†‡ˆ‹‡†
Ŷ déclarer et assigner une valeur à une variable
˜ƒ”›ʰɥŚ
Ŷ Les valeurs ont un type parmi: „‘‘Ž‡ƒ, —„‡”, •–”‹‰, ‘„Œ‡ –, ˆ— –‹‘, ou alors
—†‡ˆ‹‡†
• vérifiable avec: –›’‡‘ˆ
Ŷ Le type d'une variable peut changer au cours du temps:
šʰɥŚ–›’‡‘ˆšŚŵŵ‘„”‡‡–‹‡”Şʴɑ—„‡”ɑ
šʰŞɥŜɥɨŚ–›’‡‘ˆšŚŵŵ‘„”‡”²‡ŽŞʴɑ—„‡”ɑ
šʰɑŠ‡ŽŽ‘ɑŚ–›’‡‘ˆšŚŵŵ ŠƒÄ‡†‡ ƒ”ƒ –±”‡•Şʴɑ•–”‹‰ɑ
šʰɐ ‡ŽŽ‘™‘”Ž†ŠɐŚ–›’‡‘ˆšŚŵŵ ŠƒÄ‡†‡ ƒ”ƒ –±”‡•Şʴɑ•–”‹‰ɑ
šʰ–”—‡Ś–›’‡‘ˆšŚŵŵ„‘‘Ž‡²Şʴɑ„‘‘Ž‡ƒɑ
šʰ—ŽŽŚ–›’‡‘ˆšŚŵŵ‘„Œ‡–—ŽŽŞʴɑ‘„Œ‡ –ɑ
šʰ—†‡ˆ‹‡†Ś–›’‡‘ˆšŚŵŵ˜ƒŽ‡—”‘†²ˆ‹‹‡Şʴɑ—†‡ˆ‹‡†ɑ
šʰƒŚ–›’‡‘ˆšŚŵŵ‘–ރޗ„‡”Şʴɑ—„‡”ɑ
LES BASES PAR L’EXEMPLE: LES TABLEAUX
Ŷ Déclarer un tableau:
˜ƒ”’”‹‡•ʰƃɩřɪřɬřɮƄŚ
Ŷ Accéder à une entrée du tableau:
’”‹‡•ƃɥƄŚŵŵͥɩ
’”‹‡•ŜŽ‡‰–ŠŚŵŵͥɫ
’”‹‡•ƃ’”‹‡•ŜŽ‡‰–ŠŷɨƄŚŵŵͥɮ
’”‹‡•ƃɑɩɑƄŚŵŵͥɬ
’”‹‡•ŜɩŚŵŵͥ›–ƒš””‘”ś—‡š’‡ –‡†—„‡”
Ŷ Un tableau est dynamique, et peut contenir n'importe quoi:
˜ƒ”–ƒ„Ž‡ƒ—ʰƃƄŚŵŵ–ƒ„Ž‡ƒ—‹‹–‹ƒŽ‡‡–˜‹†‡
–ƒ„Ž‡ƒ—ƃɥƄʰɑ–‡•–ɑŚŵŵŽɐ‡–”²‡ɥ‡•–ƒŒ‘—–²‡‡–—‡˜ƒŽ‡—”‡•–ƒˆˆ‡ –²‡
–ƒ„Ž‡ƒ—ƃɨƄʰ–”—‡Śŵŵ‘’‡—–•–‘ ‡”†‡•–›’‡•†‹ˆˆ²”‡–•
–ƒ„Ž‡ƒ—ƃɩƄʰƇƈŚ
–ƒ„Ž‡ƒ—ƃɪƄʰ—ŽŽŚ
–ƒ„Ž‡ƒ—ƃɫƄʰ—†‡ˆ‹‡†Ś
–ƒ„Ž‡ƒ—ƃɬƄʰƃƄŚ
–ƒ„Ž‡ƒ—ƃɨɯƄʰɩŚŵŵ–”‘—‡–”‡Ž‡•‹†‡šɬ‡–ɨɯ
LES BASES PAR L’EXEMPLE: LES OBJETS
Ŷ Un objet est un ensemble de propriétés, c'est-à-dire de couples (nom, valeur)
Ŷ Déclarer un objet (object literal expression):
˜ƒ”„‘‘ʰƇ
–‘’‹ śɑ ƒ˜ƒ ”‹’–ɑř
ˆƒ–ś–”—‡ř
ɑƒŒ‘”˜‡”•‹‘ɑśɨŵŵ‡•’ƒ ‡†ƒ•Ž‡‘ś²˜‹–‡”ŠŠŠ
ƈŚ
Ŷ Accéder à une propriété de l'objet:
„‘‘Ŝ–‘’‹ Śŵŵͥɑ ƒ˜ƒ ”‹’–ɑř•›–ƒš‡’‘‹–²‡
„‘‘ƃɑˆƒ–ɑƄŚŵŵͥ–”—‡ř—‘„Œ‡–‡•–—–ƒ„Ž‡ƒ—†‡’”‘’”‹²–²•
Ŷ On peut assigner une propriété à tout moment:
„‘‘Ŝƒ—–Š‘”ʰɑ ‡ƒ—’‘–ɑŚŵŵƒŒ‘—–†‡Žƒ’”‘’”‹²–²ɐƒ—–Š‘”ɐ
„‘‘Ŝ ‘–‡–•ʰƇƈŚŵŵƒŒ‘—–†‡Žƒ’”‘’”‹²–²ɐ ‘–‡–•ɐ
„‘‘ƃɑ–‹–Ž‡ɑƄʰɑ ƒ˜ƒ ”‹’–’‘—”Ž‡•—Ž•ɑŚŵŵƒŒ‘—–†‡Žƒ’”‘’”‹²–²ɐ–‹–Ž‡ɐ
„‘‘ƃɑŽƒ‰—‡’”‹ ‹’ƒŽ‡ɑƄʰɑˆ”ƒ­ƒ‹•ɑŚŵŵ’”‘’”‹²–²ƒ˜‡ —‡•’ƒ ‡
LES BASES PAR L’EXEMPLE: TABLEAUX ET
OBJETS
˜ƒ”‡’–›ʰƃƄŚŵŵ–ƒ„Ž‡ƒ—˜‹†‡
‡’–›ŜŽ‡‰–ŠŚŵŵͥɥ
˜ƒ”’‘‹–•ʰƃŵŵ–ƒ„Ž‡ƒ—†ɐ‘„Œ‡–•
Ƈšśɥř›śɨƈř
Ƈšśɨř›śɨƈř
Ƈšśɨř›śɨřœśɩƈ
ƄŚ
˜ƒ”†ƒ–ƒʰƇŵŵ‘„Œ‡– ‘–‡ƒ–†‡•‘„Œ‡–•
’ɨśƇšśɥř›śɨƈř
’ɩśƇšśɨř›śɨƈ
ƈŚ
˜ƒ”–”‹ƒŽ•ʰƇ
–”‹ƒŽɨśƃƃɨřɩƄřƃɪřɫƄƄřŵŵ–ƒ„Ž‡ƒ—†‡–ƒ„Ž‡ƒ—Ɍƒ–”‹ ‡
–”‹ƒŽɩśƃƃɨřɩƄřƃɫřɭƄƄ
ƈŚ
LES BASES PAR L’EXEMPLE: ARITHMÉTIQUE
ɪʫɩŚŵŵͥɬ
ɪƋɩŚŵŵͥɭ
ɪŷɩŚŵŵͥɨ
ɪŵɩŚŵŵͥɨŜɬ
ɪʩɩŚŵŵͥɨŵŵ‘†—Ž‘
ɑɪɑʫɑɩɑŚŵŵͥɑɪɩɑŵŵ ‘ ƒ–²ƒ–‹‘
ɑɪɑŞɑɩɑŚŵŵͥɨŵŵ ‘˜‡”•‹‘†‡–›’‡
˜ƒ” ‘—–ʰɥŚ
‘—–ʫʫŚ
‘—–ŞŞŚ
ʫʫ ‘—–Ś
ŞŞ ‘—–Ś
‘—–ʫʰɩŚ
‘—–ŞʰɫŚ
‘—–ƋʰɬŚ
ʫɑɩɨɑŚŵŵͥɩɨŵŵ ‘˜‡”–‹–ɑɩɨɑ‡‘„”‡ɩɨ
ʫɑɩɨ–‘–‘ɑŚŵŵͥƒŵŵ ‘˜‡”•‹‘‹’‘••‹„Ž‡
’ƒ”•‡ –ſɑɩɨɑƀŚŵŵͥɩɨŵŵ ‘˜‡”–‹–ɑɩɨɑ‡‘„”‡ɩɨ
’ƒ”•‡ –ſɑɩɨ–‘–‘ɑƀŚŵŵͥɩɨŵŵ Š‡” Š‡—‡–‹‡”ƒ—†²„—–
’ƒ”•‡ Ž‘ƒ–ſɑɩɨŜɬ–‘–‘ɑƀŚŵŵͥɩɨŜɬŵŵ Š‡” Š‡—ˆŽ‘ƒ–ƒ—†²„—–
LES BASES PAR L’EXEMPLE: (IN-)ÉGALITÉS
˜ƒ”šʰɪř›ʰɩŚ
šʰʰ›ŵŵͥˆƒŽ•‡
šŠʰ›ŵŵͥ–”—‡
šʳ›ŵŵͥˆƒŽ•‡
šʴʰ›ŵŵͥ–”—‡
ɑ–™‘ɑʰʰɑ–Š”‡‡ɑŵŵͥˆƒŽ•‡
ɑ–™‘ɑʴɑ–Š”‡‡ɑŵŵͥ–”—‡ſ‘”†”‡Ž‡š‹ ‘‰”ƒ’Š‹“—‡ƀ
ˆƒŽ•‡ʰʰſšʳ›ƀŵŵͥ–”—‡
ſšʰʰɩƀĺĺſ›ʰʰɪƀŵŵͥ–”—‡
ſšʰʰɩƀŶŶſ›ʰʰɫƀŵŵͥ–”—‡
Šſšʰʰ›ƀŵŵͥ–”—‡
LES BASES PAR L’EXEMPLE: TESTS ET IF
‹ˆſ„ʰʰɥƀšʰɫŚ
‹ˆſ„ʰʰɥƀƇšʰɫŚƈ
‹ˆſ„ʰʰɥƀƇšʰɫŚ›ʰɩŚƈ
‹ˆſ„ʰʰɥƀƇ
šʰɫŚ
›ʰɩŚ
ƈ
‹ˆſ„ʰʰɥƀƇ
šʰɫŚ
›ʰɩŚ
ƈ‡Ž•‡Ƈ
šʰŞɫŚ
ƈ
‹ˆſ„ʰʰɥƀƇ
šʰɫŚ
›ʰɩŚ
ƈ‡Ž•‡‹ˆſ„ʰʰɨƀƇ
šʰŞɫŚ
ƈ
ATTENTION AUX TESTS D'ÉGALITÉ
Ŷ ʰʰ (resp. Šʰ) teste l’égalité (resp. la non-égalité) après d’éventuels changements de type
ɩʰʰɩŵŵͥ–”—‡
ɑɩɑʰʰɩŵŵͥ–”—‡ŠŠŠƒ––‡–‹‘
ɑɩɑŠʰɩŵŵͥˆƒŽ•‡ŠŠŠƒ––‡–‹‘
Ŷ ʰʰʰ (resp. Šʰʰ) teste l'égalité (resp. la non-égalité) stricte sur les types d’origine
ɑɩɑʰʰʰɩŵŵͥˆƒŽ•‡
ɑɩɑŠʰʰɩŵŵͥ–”—‡
Utiliser cette syntaxe le plus souvent possible
Ŷ inégalité et conversion
ɑɩɩɑʴɑɪɑŵŵͥˆƒŽ•‡
ʫɑɩɩɑʴɑɪɑŵŵͥ–”—‡
TABLEAUX D'ÉGALITÉS
ATTENTION AUX TESTS SANS ÉGALITÉ
Ŷ Les tests suivants sont évalués à ˆƒŽ•‡ (ce sont les seuls 6 cas) et donc le code dans la
boucle ne s'exécute pas
‹ˆſˆƒŽ•‡ƀƇŜŜŜƈ
‹ˆſɥƀƇŜŜŜƈ
‹ˆſɑɑƀƇŜŜŜƈ
‹ˆſ—ŽŽƀƇŜŜŜƈ
‹ˆſ—†‡ˆ‹‡†ƀƇŜŜŜƈ
‹ˆſƒƀƇŜŜŜƈƀ
Ŷ Tout le reste s'évalue à –”—‡ et donc le code dans la boucle s'exécute
‹ˆſ–”—‡ƀƇŜŜŜƈ
‹ˆſɨƀƇŜŜŜƈ
‹ˆſŞɨƀƇŜŜŜƈ
‹ˆſɑ–”—‡ɑƀƇŜŜŜƈ
‹ˆſɑˆƒŽ•‡ɑƀƇŜŜŜƈ
‹ˆſɑɨɑƀƇŜŜŜƈ
‹ˆſɑɥɑƀƇŜŜŜƈ
‹ˆſ ˆ‹‹–›ƀƇŜŜŜƈ
‹ˆſƃƄƀƇŜŜŜƈ
‹ˆſƇƈƀƇŜŜŜƈ
‹ˆſƃɥƄƀƇŜŜŜƈ
‹ˆſƃɨƄƀƇŜŜŜƈ
LES BASES PAR L’EXEMPLE: BOUCLES
™Š‹Ž‡ſŜŜŜƀƇ
ŜŜŜ
ƈ
†‘Ƈ
ŜŜŜ
ƈ™Š‹Ž‡ſŜŜŜƀŚ
˜ƒ”‹Ś
ˆ‘”ſ‹ʰɥŚ‹ʳɨɥŚ‹ʫʫƀƇ
ŜŜŜ
ƈ
ŵŵ†² Žƒ”ƒ–‹‘†‡Žƒ˜ƒ”‹ƒ„Ž‡†ɐ‹–²”ƒ–‹‘†ƒ•Žƒ„‘— Ž‡
ˆ‘”ſ˜ƒ”ŒʰɥŚ‹ʳɨɥŚ‹ʫʫƀƇ
ŜŜŜ
ƈ
ŵŵ²—²”ƒ–‹‘†‡•’”‘’”‹²–²•†ɐ—‘„Œ‡–
ˆ‘”ſ˜ƒ”ƒ‹‘„ŒƀƇ
ŜŜŜ
ƈ
LES BASES PAR L’EXEMPLE: SWITCH
ŵŵ–‡•–†ɐ‡‰ƒŽ‹–²•–”‹ –‡
•™‹– Šſ–›’‡ƀƇ
ƒ•‡ɑƒɑśŵŵ•–”‹‰
ŜŜŜ
„”‡ƒŚ
ƒ•‡ɨśŵŵ—„‡”
ŜŜŜ
„”‡ƒŚ
†‡ˆƒ—Ž–ś
ŜŜŜ
ƈ
LES FONCTIONS
FONCTIONS ET ARGUMENTS
Ŷ Les arguments sont séparés par des virgules, et utilisés dans l'ordre
Ŷ Les arguments non spécifiés ont la valeur —†‡ˆ‹‡†
Ŷ On peut accéder aux arguments via le tableau ƒ”‰—‡–•
ˆ— –‹‘ˆſšř›ƀƇ
‘•‘Ž‡ŜŽ‘‰ſɑšśɑʫšʫɑř›śɑʫ›ʫɑřœśɑʫƒ”‰—‡–•ƃɩƄƀŚ
ƈ
ˆſɨřɩřɪƀŚŵŵšśɨř›śɩřœśɪ
ˆſɨřɩƀŚŵŵšśɨř›śɩřœś—†‡ˆ‹‡†
ˆſɨƀŚŵŵšśɨř›ś—†‡ˆ‹‡†řœś—†‡ˆ‹‡†
PORTÉE DES VARIABLES
Ŷ en Java ou en C, les variables ont une portée bloc
Ŷ en JS une portée fonction (sauf en utilisant le mot clé ES6 Ž‡–)
ˆ— –‹‘–‡•–ſ‘ƀƇ
˜ƒ”‹ʰɥŚ
‹ˆſ‘Šʰʰ—ŽŽƀƇ
˜ƒ”ŒʰɥŚ
ˆ‘”ſ˜ƒ”ʰɥŚʳɨɥŚʫʫƀƇ
‘•‘Ž‡ŜŽ‘‰ſř‹ƀŚ
ƈ
‘•‘Ž‡ŜŽ‘‰ſƀŚŵŵŽƒ˜ƒ”‹ƒ„Ž‡‡•––‘—Œ‘—”•ƒ ‡••‹„Ž‡
ƈ
‘•‘Ž‡ŜŽ‘‰ſŒƀŚŵŵŽƒ˜ƒ”‹ƒ„Ž‡Œ‡•––‘—Œ‘—”•ƒ ‡••‹„Ž‡
ƈ
VARIABLES ET PILE D'APPELS
Ŷ Comment déterminer quelle variable utiliser quand plusieurs variables locales à des
fonctions imbriquées ont le même nom?
˜ƒ” —””‡– ‘’‡ʰɥŚŵŵ‰Ž‘„ƒŽ• ‘’‡
ſˆ— –‹‘ſƀƇ
˜ƒ” —””‡– ‘’‡ʰɨř‘‡ʰɐ• ‘’‡ɨɐŚ
ƒŽ‡”–ſ —””‡– ‘’‡ƀŚ
ſˆ— –‹‘ſƀƇ
˜ƒ” —””‡– ‘’‡ʰɩř–™‘ʰɐ• ‘’‡ɩɐŚ
ƒŽ‡”–ſ —””‡– ‘’‡ƀŚ
ſˆ— –‹‘ſƀƇ
˜ƒ” —””‡– ‘’‡ʰɪř–Š”‡‡ʰɐ• ‘’‡ɪɐŚ
ƒŽ‡”–ſ —””‡– ‘’‡ƀŚ
ƒŽ‡”–ſ‘‡ʫ–™‘ʫ–Š”‡‡ƀŚ
ƈſƀƀŚ
ƈſƀƀŚ
ƈſƀƀŚ
Ŷ Dans la pile d'appels, la variable utilisée est cherchée:
• dans la fonction courante
• dans la fonction appelante (en remontant)
• dans le code en dehors des fonctions
VARIABLE NON-DÉCLARÉE
Ŷ Une variable non déclarée est automatiquement déclarée avec comme portée la
fonction englobante (sauf si une variable de portée plus globale existe)
ˆ‘ –‹‘ƒ ‘ –‹‘ſƀƇ
ƒʰɥŚ
ƈ
équivalent à:
ˆ‘ –‹‘ƒ ‘ –‹‘ſƀƇ
˜ƒ”ƒŚ
ƒʰɥŚ
ƈ
mais la variable n'est pas assignée
ˆ‘ –‹‘ƒ ‘ –‹‘ſƀƇ
‘•‘Ž‡ŜŽ‘‰ſƒƀŚŵŵͥ—†‡ˆ‹‡†
ƒʰɥŚ
‘•‘Ž‡ŜŽ‘‰ſƒƀŚŵŵͥɥ
ƈ
PORTÉE DES FONCTIONS
Ŷ une déclaration de fonction est une déclaration de variable de type "function"
ˆ— –‹‘”—ſ‘„ŒƀƇŜŜŜƈ
”—ſƒƀŚ
est équivalent à:
”—ʰˆ— –‹‘ſ‘„ŒƀƇŜŜŜƈŵŵ˜ƒ”‹ƒ„Ž‡†‘–Žƒ˜ƒŽ‡—”‡•–—‡ˆ‘ –‹‘ƒ‘
”—ſƒƀŚ
Ŷ on peut définir une fonction à l'intérieur d'une fonction, elle ne sera pas accessible de l'exterieu
(comme pour toute autre variable)
ˆ— –‹‘”—ſ‘„ŒƀƇ
ˆ— –‹‘›”‹–ſšƀƇ
‘•‘Ž‡ŜŽ‘‰ſšƀŚ
ƈ
›”‹–ſ‘„ŒŜƒƀŚ
›”‹–ſ‘„ŒŜ„ƀŚ
ƈ
”—ſƇƒśɨř„śɑ–‘–‘ɑƈƀŚŵŵƒˆˆ‹ Š‡śɨ’—‹•–‘–‘
›”‹–ſɩƀŚŵŵ‡ˆ‡”‡ ‡””‘”ś›”‹–‹•‘–†‡ˆ‹‡†
TYPAGE AVANCÉ
Ŷ Types primitifs: contient une valeur simple, pas de méthode
• „‘‘Ž‡ƒ: –”—‡, ˆƒŽ•‡
• —„‡”: nombres entiers et réels (IEEE 754 attention à la précision), ʫ ˆ‹‹–›, Ş
ˆ‹‹–›, ƒ
ɥŜɨʫɥŜɩŚŵŵͥɥŜɪɥɥɥɥɥɥɥɥɥɥɥɥɥɥɥɫ
• •–”‹‰
• —ŽŽ
• —†‡ˆ‹‡†
ŵŵ ƒ—‰Š–›–ƒš””‘”ś‡š’‡ –‡†–‘‡ ſŝƀ
ɨŜ–‘–”‹‰ſƀŚ
–”—‡Ŝ–‘–”‹‰ſƀŚ
—ŽŽŜ–‘–”‹‰ſƀŚ
ɑ–‘–‘ɑŜ–‘–”‹‰ſƀŚ
—†‡ˆ‹‡†Ŝ–‘–”‹‰ſƀŚ
TYPAGE AVANCÉ
Ŷ Types complexes, c'est-à-dire avec des méthodes prédéfinies
• „Œ‡ – et ses types dérivés
- ‘‘Ž‡ƒ, —„‡”, –”‹‰, ””ƒ›, ƒ–Š, ƒ–‡, ‡‰‡š’, — –‹‘, ‡–, ...
˜ƒ”„ʰ‡™‘‘Ž‡ƒſ–”—‡ƀŚ
„Ŝ–‘–”‹‰ſƀŚŵŵͥɑ–”—‡ɑ
˜ƒ”ʰ‡™—„‡”ſɪŜɨɫƀŚ
Ŝ–‘–”‹‰ſƀŚŵŵͥɑɪŜɨɫɑ
ATTENTION AUX TYPES
Ŷ Les variables de type primitif ne sont pas des objets, ce qui peut donner lieu à des
comportements bizarres (type coercion)
˜ƒ”•ʰɑŠ‡ŽŽ‘ř™‘”Ž†ɑŚ
–›’‡‘ˆ•Śŵŵͥɑ•–”‹‰ɑ–›’‡’”‹‹–‹ˆř’ƒ•—‘„Œ‡–
•ŜšʰɨɬŚŵŵͥɨɬ’ƒ•†ɐ‡””‡—” ƒ”²“—‹˜ƒŽ‡–ſ‡™–”‹‰ſ•ƀƀŜšʰɨɬ
–›’‡‘ˆ•Śŵŵͥɑ•–”‹‰ɑ•ɐƒ’ƒ• Šƒ‰²†‡–›’‡
•Ŝšŵŵͥ—†‡ˆ‹‡†’”‘„Ž±‡ ƒ”Žɐ‘„Œ‡––”‹‰–‡’‘”ƒ‹”‡ƒ†‹•’ƒ”—
Ŷ Dans ce cas, utiliser directement une variable de type Object, plus précisément de type
String
•ʰ‡™–”‹‰ſɑŠ‡ŽŽ‘ř™‘”Ž†ɑƀŚ
–›’‡‘ˆ•Śŵŵͥ‘„Œ‡ –ś•‡•–—‘„Œ‡–’ƒ”–‡–‹±”‡
•ŜšʰɨɬŚŵŵͥɨɬ
•ŜšŚŵŵͥɨɬŽƒ’”‘’”‹²–²‡•–’‡”•‹•–‡–‡
STRING
˜ƒ”•ʰ‡™–”‹‰ſɑŠ‡ŽŽ‘ř™‘”Ž†ɑƀŚ
•Ŝ Šƒ”–ſɥƀŚ
•Ŝ Šƒ”–ſ•ŜŽ‡‰–ŠŞɨƀŚ
•Ŝ•—„•–”‹‰ſɨřɫƀŚ
•Ŝ•Ž‹ ‡ſɨřɫƀŚ
•Ŝ•Ž‹ ‡ſŞɪƀŚ
•Ŝ‹†‡šˆſɑŽɑƀŚ
•ŜŽƒ•– †‡šˆſɑŽɑƀŚ
•Ŝ‹†‡šˆſɑŽɑřɪƀŚ
•Ŝ•’Ž‹–ſɑřɑƀŚ
•Ŝ”‡’Žƒ ‡ſɑŠɑřɑ ɑƀŚ
•Ŝ–‘’’‡”ƒ•‡ſƀŚ
MATH
ƒ–ŠŜ’‘™ſɩřɬɪƀŚ
ƒ–ŠŜ”‘—†ſŜɭƀŚ
ƒ–ŠŜ ‡‹ŽſŜɭƀŚ
ƒ–ŠŜˆŽ‘‘”ſŜɭƀŚ
ƒ–ŠŜƒ„•ſŞɬƀŚ
ƒ–ŠŜƒšſšř›řœƀŚ
ƒ–ŠŜ‹ſšř›řœƀŚ
ƒ–ŠŜ”ƒ†‘ſƀŚ
ƒ–ŠŜ Ś
ƒ–ŠŜŚ
ƒ–ŠŜ•“”–ſɪƀŚ
ƒ–ŠŜ’‘™ſɪřɨŵɪƀŚ
ƒ–ŠŜ•‹ſɥƀŚ
ƒ–ŠŜŽ‘‰ſɨɥƀŚ
ƒ–ŠŜŽ‘‰ſɨɥɥƀŚ
ƒ–ŠŜɨɥŚ
ƒ–ŠŜŽ‘‰ſɬɨɩƀŚ
ƒ–ŠŜɩŚ
ƒ–ŠŜ‡š’ſɪƀŚ
ARRAY
ƒʰ‡™””ƒ›ſƀŚŵŵ ‘•–”— –‡—”‘”‡ ‘ƒ†²
ƒʰƃƄŚŵŵ ‘•–”— –‡—””‡ ‘ƒ†²
ƒʰƃɨřɩřɪƄŚ
ƒŜŽ‡‰–ŠŚŵŵͥɪ
ƒŜ’—•ŠſɫƀŚ
„ʰƒŜ’‘’ſƀŚŵŵͥɫ
†‡Ž‡–‡ƒƃɨƄŚŵŵƒƃɨƄ˜ƒ—–ƒ‹–‡ƒ–—†‡ˆ‹‡†
ɨ‹ƒŚŵŵͥˆƒŽ•‡
ƒŜŽ‡‰–ŠŚŵŵͥɪśŽ‘‰—‡—”‘‘†‹ˆ‹²‡’ƒ”†‡Ž‡–‡
ƒŜŒ‘‹ſƀŚŵŵͥɑɨřɩřɪɑ
ƒŜŒ‘‹ſɑɑƀŚŵŵͥɑɨɩɪɑ
ƒŜ”‡˜‡”•‡ſƀŚ
ƒŜ•‘”–ſƀŚ
ƒŜ ‘ ƒ–ſŝƀŚ
ƒŜ•Ž‹ ‡ſŝƀŚŵŵŞɨ‡•–Ž‡†‡”‹‡”‡Ž‡‡–řŞɪŽɐƒ–‡’‡—Ž–‹±‡ŝ
ƒŜ•’Ž‹ ‡ſŝƀŚŵŵ Š‹”—”‰‹‡ ‘’Ž‡š‡
ƒŜ•Š‹ˆ–ſƀŚŵŵʰ’‘’‰ƒ— Š‡
ƒŜ—•Š‹ˆ–ſƀŚŵŵ’—•Š‰ƒ— Š‡
ƒŜ–‘–”‹‰ſƀŚŵŵ ‘‡Œ‘‹ſƀ
ARRAY EN ES 5
ƒŜˆ‘”ƒ ŠſˆƀŚŵŵƒ’’Ž‹“—‡”—‡ˆ‘ –‹‘
ƒŜƒ’ſˆƀŚŵŵʫ”‡–‘—”–ƒ„Ž‡ƒ—”²•—Ž–ƒ–•
ƒŜˆ‹Ž–‡”ſˆƀŚŵŵ•‡Ž‡ –‹‘•‡Ž‘’”²†‹ ƒ–
ƒŜ‡˜‡”›ſˆƀŚŵŵĺ啗”’”²†‹ ƒ–
ƒŜ•‘‡ſˆƀŚŵŵŶŶ•—”’”²†‹ ƒ–
ƒŜ”‡†— ‡ſˆř‹ƀŚŵŵƒ’’Ž‹“—‡ˆ–‘—•Ž‡•²Ž²‡–•†‡‰ƒ— Š‡†”‘‹–‡
ŵŵ‡–”‡–‘—”‡Ž‡”²•—Ž–ƒ–ƒ ——Ž²
ƒŜ”‡†— ‡‹‰Š–ſˆř‹ƀŚŵŵ†‡†”‘‹–‡‰ƒ— Š‡
ƒŜ‹†‡šˆſ‹ƀŚ
ƒŜŽƒ•– †‡šˆſ‹ƀŚ
””ƒ›Ŝ‹•””ƒ›ſƒƀŚ
THIS
Ŷ –Š‹• est un mot-clé, similaire mais différent des autres langages (tel que Java ou C++)
Ŷ Le code JavaScript s'exécute (presque) toujours avec un –Š‹• défini:
• En dehors d'une fonction, –Š‹• représente le contexte d'exécution global, c'est-à-dire:
- L'objet ™‹†‘™ dans les navigateurs
–Š‹•ʰʰʰ™‹†‘™Śŵŵ–”—‡
- L'objet ‰Ž‘„ƒŽ dans NodeJS
–Š‹•ʰʰʰ‰Ž‘„ƒŽŚŵŵ–”—‡
• Dans une fonction:
- l'objet sur lequel la fonction a été appelée (s'il existe),
- le –Š‹• du contexte d'execution global (si pas d'objet appelant) en mode normal ou
- —†‡ˆ‹‡† en "strict mode".
THIS - EXEMPLES
˜ƒ”ʰƇƈŚ
ˆ— –‹‘ˆſƀƇ”‡–—”–Š‹•ʰʰʰŚƈ
Ŝ‰ʰˆ— –‹‘ſƀƇ
–Š‹•ŜœʰɩŚ
”‡–—”–Š‹•ʰʰʰŚ
ƈ
ˆſƀŚŵŵͥˆƒŽ•‡
Ŝ‰ſƀŚŵŵͥ–”—‡
ŜœŚŵŵͥɩśŽƒ’”‘’”‹²–²œ‡•–„‹‡ƒ••‹‰²‡•—”
–Š‹•ŜœŚŵŵͥ—†‡ˆ‹‡†śœɐ‡•–’ƒ• ‘—‡†‡Š‘”•†‡
ˆ— –‹‘ŠſƀƇ–Š‹•ŜšʰɩŚƈ
˜ƒ”ʰ‡™ŠſƀŚŵŵ–‘—–‡ˆ‘ –‹‘’‡—–³–”‡— ‘•–”— –‡—”
ŵŵ†ƒ• ‡ ƒ•ř†ƒ•Šś–Š‹•ʰʰʰͥ–”—‡
ŜšŚŵŵͥɩ
MODIFIER THIS
CALL, APPLY ET BIND
Ŷ Possibilité de donner un –Š‹• explicite/différent de l'objet normal
˜ƒ”ʰƇ
šśɩř
ˆśˆ— –‹‘ſ›řœƀƇ ‘•‘Ž‡ŜŽ‘‰ſ–Š‹•Ŝšʫ›ʫœƀŚƈ
ƈŚ
ŜˆſɨřɩƀŚŵŵɬśˆ‡•–ƒ’’‡Ž²‡ƒ˜‡ –Š‹•˜ƒŽƒ–
˜ƒ”ʰƇšśɪƈŚ
ŜˆſɨřɩƀŚŵŵ›’‡””‘”ś—†‡ˆ‹‡†‹•‘–ƒˆ— –‹‘
ŜˆŜ ƒŽŽſřɨřɩƀŚŵŵɭśˆ‡•–ƒ’’‡Ž²‡ƒ˜‡ –Š‹•˜ƒŽƒ–
ŜˆŜƒ’’Ž›ſřƃɨřɩƄƀŚŵŵɭśˆ‡•–ƒ’’‡Ž²‡ƒ˜‡ –Š‹•˜ƒŽƒ–
Ŷ Possibilité de créer une fonction avec un –Š‹• différent pour l'appeler plus tard
˜ƒ”‰ʰŜˆŜ„‹†ſřɨřɩƀŚŵŵ ”²ƒ–‹‘†ɐ—‡ˆ‘ –‹‘
ŵŵ–Š‹•‡–Ž‡•ƒ”‰—‡–••‘–’”²’‘•‹–‹‘²•
‰ſƀŚŵŵˆ‡•–ƒ’’‡Ž²‡ƒ˜‡ –Š‹•ʰ‡–Ž‡•˜ƒŽ‡—”•ɨ‡–ɩ
THAT/SELF/ME
CLOSURES
Ŷ Particularité très importante de JS, à la base de nombreuses bibliothèques JS
• Une fonction javascript peut retourner une valeur de type "fonction" (high-order
function)
• Les variables d'une fonction mise dans la pile d'appels restent disponibles après que
cette fonction ait été dépilée
ˆ— –‹‘ Š‡ • ‘’‡ſƀƇ
˜ƒ”• ‘’‡ʰɑŽ‘ ƒŽ• ‘’‡ɑŚ
ˆ— –‹‘ˆſƀƇ”‡–—”• ‘’‡Śƈŵŵɐˆɐ”²ƒŽ‹•‡—‡ Ž‘•—”‡ƒ—–‘—”†‡ɐ• ‘’‡ɐ
”‡–—”ˆŚ
ƈ
˜ƒ”šʰ Š‡ • ‘’‡ſƀŚŵŵš‡•–—‡ˆ‘ –‹‘
šſƀŚŵŵͥɑŽ‘ ƒŽ• ‘’‡ɑ
Ŷ Permet d'éviter d'exposer des variables tout en permettant leur manipulations
• Mécanisme d'encapsulation
CLOSURES: EXEMPLE D'ERREUR CLASSIQUE
ˆ— –‹‘ˆſƀƇ
˜ƒ”ƒʰƃƄŚ
ˆ‘”ſ˜ƒ”‹ʰɥŚ‹ʳɪŚ‹ʫʫƀƇ
ƒƃ‹Ƅʰˆ— –‹‘ſƀƇ ‘•‘Ž‡ŜŽ‘‰ſ‹ƀŚƈŚ
ƈ
”‡–—”ƒŚ
ƈ
˜ƒ”„ʰˆſƀŚ
„ƃɥƄſƀŚŵŵͥɪ
„ƃɨƄſƀŚŵŵͥɪ
„ƃɩƄſƀŚŵŵͥɪ
Ŷ Explication du problème:
• f n'est appelée qu'une seule fois: une seule variable i est présente dans l'espace réservé à
f dans la pile d'appels
• Au moment d'appeler b[n], dans cet espace, i vaut 3
CLOSURES: CORRECTION
ˆ— –‹‘‰ſŒƀƇ
”‡–—”ˆ— –‹‘ſƀƇ ‘•‘Ž‡ŜŽ‘‰ſŒƀŚƈŚ
ƈ
ˆ— –‹‘ˆſƀƇ
˜ƒ”ƒʰƃƄŚ
ˆ‘”ſ‹ʰɥŚ‹ʳɪŚ‹ʫʫƀƇ
ƒƃ‹Ƅʰ‰ſ‹ƀŚ
ƈ
”‡–—”ƒŚ
ƈ
˜ƒ”„ʰˆſƀŚ
„ƃɥƄſƀŚŵŵͥɥ
„ƃɨƄſƀŚŵŵͥɨ
„ƃɩƄſƀŚŵŵͥɩ
Ŷ Solution:
• On résoud le problème en appelant n fois une autre fonction
• qui va créer n espaces de stockage dans la pile d'appels pour j
CLOSURES: CORRECTION (2)
ˆ— –‹‘ˆſƀƇ
˜ƒ”ƒʰƃƄŚ
ˆ‘”ſ‹ʰɥŚ‹ʳɪŚ‹ʫʫƀƇ
ƒƃ‹Ƅʰſˆ— –‹‘ſŒƀƇ
”‡–—”ˆ— –‹‘ſƀƇ ‘•‘Ž‡ŜŽ‘‰ſŒƀŚƈŚ
ƈƀſ‹ƀŚ
ƈ
”‡–—”ƒŚ
ƈ
˜ƒ”„ʰˆſƀŚ
„ƃɥƄſƀŚŵŵͥɥ
„ƃɨƄſƀŚŵŵͥɨ
„ƃɩƄſƀŚŵŵͥɩ
Ŷ Plus compact en créant une fonction anonyme, auto-appelée
• pratique courante dans les bibliothèques JS
• à éviter
UTILISATION DES CLOSURES
FAIRE DES MODULES SANS CLOSURE
˜ƒ”›„Œ‡ –ʰƇ
„ɏ‰‡–śɥř
’”‹˜ƒ–‡ɏ˜ƒŽ—‡śɨɪř
’—„Ž‹ ɏ˜ƒŽ—‡śɑ–‘–‘ɑř
‰‡–śˆ— –‹‘ſƀƇ
„ɏ‰‡–ʫʫŚ
”‡–—”’”‹˜ƒ–‡ɏ˜ƒŽ—‡Ś
ƈ
•‡–śˆ— –‹‘ſšƀƇ
„ɏ‰‡–ʰɥŚ
–Š‹•Ŝ’”‹˜ƒ–‡ɏ˜ƒŽ—‡ʰšŚ
ƈ
ƈ
˜ƒ”ƒʰ›„Œ‡ –Ŝ‰‡–ſƀŚ
˜ƒ”šʰ›„Œ‡ –Ŝ’”‹˜ƒ–‡ɏ˜ƒŽ—‡Ś
›„Œ‡ –Ŝ•‡–ſɨƀŚ
›„Œ‡ –Ŝ’”‹˜ƒ–‡ɏ˜ƒŽ—‡ʰɩɩŚ
Ŷ possibilité d'accéder à 'private_value' sans garder 'nb_get' cohérent
UTILISATION DES CLOSURES
FAIRE DES MODULES
˜ƒ”‡š’‘•‡†ʰſˆ— –‹‘ſƀƇ
˜ƒ”’”‹˜ƒ–‡ɏ˜ƒŽ—‡ʰɨɪŚ
˜ƒ”„ɏ‰‡–ʰɥŚ
˜ƒ”‹ˆƒ ‡ʰƇƈŚ
‹ˆƒ ‡Ŝ’—„Ž‹ ɏ˜ƒŽ—‡ʰɑ–‘–‘ɑŚ
‹ˆƒ ‡Ŝ•‡–ʰˆ— –‹‘ſšƀƇ
„ɏ‰‡–ʰɥŚ
’”‹˜ƒ–‡ɏ˜ƒŽ—‡ʰšŚ
ƈŚ
‹ˆƒ ‡Ŝ‰‡–ʰˆ— –‹‘ſƀƇ
„ɏ‰‡–ʫʫŚ
”‡–—”’”‹˜ƒ–‡ɏ˜ƒŽ—‡Ś
ƈŚ
”‡–—”‹ˆƒ ‡Ś
ƈƀſƀŚ
‡š’‘•‡†Ŝ’—„Ž‹ ɏ˜ƒŽ—‡Śŵŵͥɑ–‘–‘ɑ
‡š’‘•‡†Ŝ‰‡–ſƀŚŵŵͥɨɪ
Ŷ closure autour de 'private_value' pour cacher la mécanique interne (encapsulation)
Ŷ objet retourné comme interface (fonctions et attributs)
JAVASCRIPT
PROGRAMMATION ORIENTÉ-OBJET
Ŷ JavaScript est orienté-objet
• possède la notion d'objet
• mais pas la notion de "classe" (sauf à partir de ES 6)
• remplacée par la notion très particulière de prototype
- qui permet de reproduire la notion de "classe"
- et plus
• possède la notion d'héritage
- mais pas de polymorphisme
LES OBJETS
CONSTRUCTEUR ET INITIALISATION
˜ƒ”ƒʰƇƈŚ
ƒŜšʰɩŚ
ƒŜˆʰˆ— –‹‘ſƀƇŜŜŜƈŚ
˜ƒ”„ʰƇ
œśɑ–‡•–ɑř
‰śˆ— –‹‘ſƀƇŜŜŜƈ
ƈ
ˆ— –‹‘Šſ’ƒ”ɨř’ƒ”ɩƀƇ
–Š‹•Ŝ’ƒ”ɨʰ’ƒ”ɨŚ
–Š‹•Ŝ’ƒ”ɩʰ’ƒ”ɩŚ
–Š‹•Ŝʰˆ— –‹‘ſƀƇŜŜŜƈŚ
ƈ
ŵŵ‘—–‡ˆ‘ –‹‘’‡—–†‡˜‡‹”— ‘•–”— –‡—”ƒ˜‡ ɐ‡™ɐ
˜ƒ” ʰ‡™Šſɨřɑ–‘–‘ɑƀŚ
˜ƒ”†ʰ‡™„Œ‡ –ſƀŚ
˜ƒ”‡ʰ„Œ‡ –Ŝ ”‡ƒ–‡ſƀŚ
PROTOTYPE ET HÉRITAGE
Ŷ On peut indiquer qu'un objet hérite les propriétés d'un autre objet
Ŷ en modifiant la propriété ’”‘–‘–›’‡ du constructeur
ˆ— –‹‘ſšƀƇ–Š‹•ŜšʰšŚƈŵŵ— ‘•–”— –‡—”
˜ƒ”ƒʰ‡™ſɥƀŚŵŵƒ˜ƒ—–Ƈšśɥƈ
ƒŜ ‘•–”— –‘”Śŵŵ
Ŝ’”‘–‘–›’‡ʰƇ›śɩƈŚŵŵ–‘—•Ž‡•‘„Œ‡–• ”²²•’ƒ”
ŵŵƒ—”‘–ƒ‹–‡ƒ–—‡’”‘’”‹²–²›
˜ƒ”„ʰ‡™ſɨƀŚŵŵ„˜ƒ—–Ƈšśɨř›śɩƈ
˜ƒ” ʰ‡™ſɪƀŚŵŵ ˜ƒ—–Ƈšśɪř›śɩƈ
ƒŚŵŵƒ˜ƒ—––‘—Œ‘—”•Ƈšśɥƈ
ŵŵ ƒ”‹Žɐƒ’ƒ•Ž‡³‡’”‘–‘–›’‡
Ŝ’”‘–‘–›’‡Ŝ–ʰɑ–‘–‘ɑŚŵŵ—’”‘–‘–›’‡‡•–—‘„Œ‡– ‘‡—ƒ—–”‡
„Śŵŵ„˜ƒ—–Ƈšśɨř›śɩř–śɑ–‘–‘ɑƈ
Śŵŵ ˜ƒ—–Ƈšśɪř›śɩř–śɑ–‘–‘ɑƈ
ƒŚŵŵƒ˜ƒ—––‘—Œ‘—”•Ƈšśɥƈ
Ŷ On peut aussi utiliser „Œ‡ –Ŝ ”‡ƒ–‡
˜ƒ”†ʰ„Œ‡ –Ŝ ”‡ƒ–‡ſƇ›śɩƈƀŚ
PROTOTYPE ET CHAÎNE D'HÉRITAGE
Ŷ Quand on accède à une propriété d'un objet, cette propriété (potentiellement une
fonction) est cherchée en remontant la chaîne de prototype (héritage):
• soit elle est sur l'objet: c'est sa propre propriété (‘„ŒŜŠƒ•™”‘’‡”–›ſƀ)
• si son prototype est non-null, on cherche récursivement sur l'objet prototype
• sinon la propriété n'existe pas
ˆ— –‹‘ſƀƇ
–Š‹•Ŝ’”‹–ʰˆ— –‹‘ſƀƇ ‘•‘Ž‡ŜŽ‘‰ſɑŠ‡ŽŽ‘ɑƀŚƈŚ
–Š‹•Ŝ‹’”‹‡ʰˆ— –‹‘ſƀƇ ‘•‘Ž‡ŜŽ‘‰ſɑ„‘Œ‘—”ɑƀŚƈ
ƈ
˜ƒ”ƒʰ‡™ſƀŚ
ˆ— –‹‘ſƀƇ
–Š‹•Ŝ’”‹–ʰˆ— –‹‘ſƀƇ ‘•‘Ž‡ŜŽ‘‰ſɑŠ‡ŽŽ‘™‘”Ž†ŠɑƀŚƈŚ
ƈ
Ŝ’”‘–‘–›’‡ʰ‡™ſƀŚ
˜ƒ”„ʰ‡™ſƀŚ
„Ŝ’”‹–ſƀŚŵŵŠ‡ŽŽ‘™‘”Ž†Š
„Ŝ‹’”‹‡ſƀŚŵŵ„‘Œ‘—”
„‹•–ƒ ‡‘ˆŚŵŵ–”—‡
ƒ‹•–ƒ ‡‘ˆŚŵŵˆƒŽ•‡
Ŷ Quand on appelle une fonction héritée, –Š‹• représente l'objet (pas le prototype)
OBJET
PROPRIÉTÉ D'INSTANCE ET PROPRIÉTÉ STATIQUE
Propriété de toutes les instances
ˆ— –‹‘ ſšƀƇ–Š‹•ŜšʰšŚƈ
˜ƒ”ˆʰ‡™ ſɨɥƀŚ
ˆŜšŚ
˜ƒ”‰ʰ‡™ ſɨɩƀŚ
‰ŜšŚ
Propriété d'une instance
ˆ— –‹‘ ſšƀƇ–Š‹•ŜšʰšŚƈ
˜ƒ”ˆʰ‡™ ſɨɥƀŚ
ˆŜœʰɩŚ
˜ƒ”‰ʰ‡™ ſɨɩƀŚ
‰ŜœŚŵŵ—†‡ˆ‹‡†
Propriété statique
ˆ— –‹‘ ſšƀƇ–Š‹•ŜšʰšŚƈ
Ŝ™ʰɪŚ
˜ƒ”ˆʰ‡™ ſɨɥƀŚ
ˆŜ™Śŵŵ—†‡ˆ‹‡†Ś
Ŝ™Śŵŵɪ
AJOUTER DES MÉTHODES À UNE CLASSE
Ŷ JavaScript est dynamique
Ŷ On peut ajouter des méthodes à un prototype, y compris d'une classe "système"
(attention!)
””ƒ›Ŝ’”‘–‘–›’‡Ŝ”‡‘˜‡ʰˆ— –‹‘ſ‘„ŒƀƇ
˜ƒ”‹ʰ–Š‹•Ŝ‹†‡šˆſ‘„ŒƀŚ
‹ˆſ‹ʴʰɥƀƇ
–Š‹•Ŝ•’Ž‹ ‡ſ‹řɨƀŚ
ƈ
ƈŚ
–”‹‰Ŝ’”‘–‘–›’‡Ŝ–”‹ʰ–”‹‰Ŝ’”‘–‘–›’‡Ŝ–”‹ŶŶˆ— –‹‘ſƀƇ
‹
ˆſŠ–Š‹•ƀ”‡–—”–Š‹•Ś
”
‡–—”–Š‹•Ŝ”‡’Žƒ ‡ſŵɋɎ•ʫŶɎ•ʫɛŵ‰řɑɑƀŚ
ƈŚ
ATTENTION: FOR/IN
Ŷ Les boucles ˆ‘”ſƒ‹„ƀƇŝƈ incluent les propriétés héritées
Ŷ Sauf si on utilise Šƒ•™”‘’‡”–›ſƀ
ˆ‘”ſƒ‹„ƀƇ
‹ˆſ„ŜŠƒ•™”‘’‡”–›ſƒƀƀƇ
ŝ
ƈ
ƈ
JAVASCRIPT STRICT
Ŷ Possibilité d'utiliser une version plus stricte de JavaScript
ɑ—•‡•–”‹ –ɑŚ
ˆ— –‹‘ˆſƀƇ
ɑ—•‡•–”‹ –ɑŚ
ƈ
• ˜ƒ” n'est pas optionnel
• fonctions appelées sans –Š‹•: –Š‹• est —†‡ˆ‹‡†, au lieu d'être l'objet global
• des erreurs "silencieuses" font un throw
• ‡˜ƒŽſƀ ne crée rien dans global (pas de variables, pas de fonctions)
• pas de ™‹–Š
"EVAL IS EVIL"
Ŷ Possibilité d'évaluer une chaîne de caractères comme étant du JavaScript
‡˜ƒŽſɑɪʫɩɑƀŚŵŵͥɬ
Ŷ ‡˜ƒŽ est une fonction qui s'exécute là où elle est appelée, dans le contexte local
Ŷ à éviter: empèche les optimisations
NETTOYER SON CODE
Ŷ JSHint
Ŷ JSLint
JS DANS LE SERVEUR
Ŷ ‘†‡ŜŒ•: environnement d'execution de programmes JavaScript (moteur V8) en ligne de
commande
• permet d'utiliser JavaScript en dehors du navigateur
• usage similaire à plein d'autres langages (java.exe, perl, python, ...)
Ŷ démon http inclus, par défaut
• permet de déployer un serveur web facilement
• de développer la logique serveur en JavaScript
• équivalent de J2EE, Apache Tomcat et les servlets en Java
Ŷ Dispose d'un système de modules
• possiblité d'importer une bibliothèque développée par quelqu'un d'autre
• il existe un gestionnaire de modules/package: ’
JSON
Ŷ Utilisation de la syntaxe litterale JS pour transmettre des données
Ŷ Lecture/ecriture:
‘„Œʰ Ŝ’ƒ”•‡ſŽ‹‡ƀŚ
Ž‹‡ʰ Ŝ•–”‹‰‹ˆ›ſ‘„ŒƀŚ
Ŷ Exemple:
Ŝ•–”‹‰‹ˆ›ſ„‘‘ƀŵŵͥ
ɐƇɑ–‘’‹ ɑśɑ ƒ˜ƒ ”‹’–ɑřɑˆƒ–ɑś–”—‡řɑƒ—–Š‘”ɑśɑ ‡ƒ—’‘–ɑřɑ ‘–‡–•ɑśƇƈƈɐ
Ŷ disponibilité
• extension courante de ES3
• natif dans ES5
NOUVEAUTÉS ES 6