Javascript

Javascript
Logó.
A JavaScript cikk szemléltető képe
Az első változat kelte 1996. május
Paradigma Több paradigma  : szkript , objektumorientált ( prototípus-orientált ), imperatív , funkcionális
Szerző Brendan Eich
Fejlesztők Netscape Communications Corporation , Mozilla Alapítvány
Utolsó verzió 11 - ES2020 (2020 június)
Gépelés dinamikus , gyenge
Szabványok ECMA-262
ISO / IEC 16262
Nyelvjárások JavaScript, JScript , ECMAScript
Befolyásolta Self , Scheme , Perl , C , C ++ , Java , Python
Befolyásolt JScript , JScript .NET , Objective-J , TIScript
Végrehajtások SpiderMonkey , Rhino , KJS , JavaScriptCore , V8
Weboldal Mozilla
Fájlkiterjesztés js

JavaScript egy programozási nyelv a szkriptek főként a weboldalak , interaktív és mint ilyen, elengedhetetlen része a webes alkalmazások . A HTML és CSS technológiákkal együtt a JavaScriptet néha a világháló egyik alapvető technológiájának tekintik . A nagy többsége honlapok használja, és a legtöbb webböngésző egy dedikált JavaScript motort , hogy értelmezze azt , függetlenül attól, hogy a biztonsági szempontok merülhetnek fel, ha szükséges.

Ez egy objektumorientált to- prototípusa orientált nyelv  : az alapjait a nyelv és a fő pontok által biztosított tárgyakat .

Azonban, ellentétben egy objektum-orientált nyelv, alap tárgyak nem esetekben az osztályokba .

Minden alapobjektumnak (pl. A dokumentum vagy a Windows objektumnak) megvan a saját modellje, amely lehetővé teszi a gyermekobjektumok példányosítását a konstruktorok segítségével a tulajdonságai alapján. Például a prototípus-tulajdonság lehetővé teszi számukra egyedi örökös objektumok létrehozását .

Ezen kívül funkciók vannak első osztályú objektumokat . A nyelv támogatja az objektumot , az imperatív és funkcionális paradigmát . A JavaScript az npm függőségkezelőjének köszönhetően a legnagyobb ökoszisztémával rendelkezik, mintegy 500 000 csomaggal2017. augusztus.

A JavaScriptet 1995-ben hozta létre Brendan Eich . Azt szabványosítani néven ECMAScript a1997. júniusaz Ecma International az ECMA-262 szabvány szerint. A szabvány jelenlegi változata, 2020 júniusa óta, a 11. kiadás.

A JavaScript az ECMAScript implementációja, amelyet a Mozilla Alapítvány valósított meg . Az ECMAScript Microsoft általi implementációját (az Internet Explorerben a 9. verzióig) JScript-nek , míg az Adobe Systems implementációját ActionScript-nek hívják .

A JavaScriptet olyan kiszolgálókhoz is használják, amelyek például (például) a Node.js-t vagy a Deno-t használják .

Történelem

Rajt

A nyelvet 1995 májusában tíz nap alatt hozta létre a Netscape Communications Corporation megbízásából Brendan Eich , akit sok nyelv, különösen a Java ihletett, de a kezdők számára egyszerűsítette a szintaxist . Brendan Eich már eredetileg kifejlesztett egy szerver oldali programozási nyelv úgynevezett LiveScript, hogy erősítse a kereskedelmi ajánlat HTTP szerver számára Mosaic Communications Corporation . A LiveScript kiadása akkor történt, amikor az NCSA arra kényszerítette a Mosaic Communications Corporation-t, hogy változtassa meg a nevét Netscape Communications Corporation-re, majd a Netscape a LiveScript kliensorientált változatának fejlesztésén dolgozott. Néhány nappal a megjelenés előtt a Netscape megváltoztatja a nevet LiveScript-ről JavaScript-re. A Sun Microsystems és a Netscape partnerek voltak, és az egyre népszerűbb Java virtuális gép . Ez a névváltozás mindkét vállalat érdekeit szolgálta.

Ban ben 1995. december, A Sun és a Netscape bejelenti a JavaScript kiadását. Ban ben 1996 márciusNetscape hajtja végre a JavaScript motort annak Netscape Navigator 2.0 web böngésző . Ennek a böngészőnek a sikere hozzájárul a JavaScript gyors elterjedéséhez az ügyfélorientált webfejlesztésben. A Microsoft ezután reagál a JScript fejlesztésével , amelyet azután beépít az Internet Explorer 3.0-ba 1996 augusztus böngészőjének kilépéséért.

A JavaScriptet a Java kiegészítéseként írják le a Netscape és a Sun Microsystems dátumozott közös sajtóközleményében 1995. december 4. Ez a kezdeményezés segített a zavart kelteni a nyilvánosság körében a két szintaktikailag hasonló, de alapfogalmukban egyáltalán nem, és a mai napig tartó nyelv között.

A "JavaScript" az Oracle bejegyzett védjegyévé válik az Egyesült Államokban 1997 május.

Szabványosítás

Ezután a Netscape elküldi a JavaScript-et az Ecma International- nek szabványosítás céljából.

1. verzió: Az ECMA-262 szabvány megszületése

A munka kezdődik 1996 november és vége 1997. június, A szülés, hogy a 1 -jén  kiadása az ECMA-262 szabvány, amely meghatározza a nyelv ECMAScript . A szabványt ezután benyújtják az ISO / IEC-hez és közzéteszik 1998 április mint az ISO / IEC 16262 nemzetközi szabvány.

2. verzió: Homogenizálás az ISO / IEC 16262 szabvány szerint

Szerkesztési változtatásokat az ECMA-262 szabvány, hogy megfeleljenek a nemzetközi szabvány az ISO / IEC 16262, így a 2 második  kiadása az ECMA-262 szabvány 1998. június.

3. változat: A nyelv fejlesztése és felépítése

A 3 -én  kiadása a ECMA-262 szabvány bevezette:

  • erősebb reguláris kifejezések,
  • a karakterláncok jobb kezelése,
  • új vezérlési utasítások,
  • kivételkezelés try / catch utasításokkal
  • számok formázása.

Az Ecma International kiadja 1999. december majd benyújtották az ISO / IEC-hez, amely az ISO / IEC 16262: 2002 nemzetközi szabványt publikálja 2002. június. Közzétételét követően a 3 rd  edition következőképpen masszív elfogadását összes böngészők.

4. verzió: A befejezetlen szakasz

A következetes munka folyik, hogy fejlesszék a 4 th  kiadás a szabvány az ECMA-262, de ez nem fog az idén elkészül, és soha nem fogja látni a napot. Azonban, része a fejlesztési elvégzett kell építeni a 6 th  kiadás.

5. verzió: Pontosítás és új funkciók

Az 5 -én  kiadása az ECMA-262 szabvány tisztázza a kétértelműséget, amely a 3 -én  kiadása és bemutatja getter, önvizsgálat, ellenőrzés attribútumok további táblákat képességeivel támogatja a formátumot JSON és a szigorú módban hibajavítás. Az Ecma International kiadja 2009. december majd benyújtják az ISO / IEC-nek, amely kisebb javításokat végez és az ISO / IEC 16262: 2011 nemzetközi szabványt közzéteszi 2011. június. Ugyanezen a napon jelent meg az ECMA-262 szabvány 5.1. Kiadása, amely megegyezik az ISO / IEC 16262: 2011 nemzetközi szabvány szövegével.

6. verzió: Javított támogatás és funkcionalitás

Bár a fejlesztés a 6 th  kiadás a szabvány az ECMA-262 indult hivatalosan 2009-ben, röviddel a kiadvány az 5 th  kiadás, azt közzé 2015. júniusvalójában a betetőzése 15 év munkája megjelenése óta a 3 rd  edition 1999 A cél ennek a 6 th  változat az, hogy jobban megfeleljen a nagyszabású alkalmazások létrehozását, könyvtárak és használata ECMAScript mint egy összeállítás más nyelvek célzása. Ez a kiadás bemutatja a modulokat, osztályokat, a lexikális hatókört blokkszinten, az iterátorokat és a generátorokat, ígéreteket az aszinkron programozásra, a struktúrák megsemmisítésére, a terminálhívások optimalizálására, új adatstruktúrákra (asszociatív tömbök, halmazok, bináris tömbök), további Unicode karakterek támogatására karakterláncokban és reguláris kifejezésekben, valamint az előre meghatározott adatstruktúrák kiterjesztésének képessége.

A 7. verziótól a mai napig: állandó adaptáció a webes eszközökhöz

A 7 -én  kiadása a szokásos ECMA-262 Edition az első kérdése az új, nyitott fejlesztési folyamat és az éves közzététele üteme által elfogadott Ecma TC39 bizottság. A szöveges dokumentum jön létre a 6 th  kiadás és feltették GitHub mint fejlesztési alap ebben az új kiadásban. Korrekció után több ezer hibákat és szerkesztői hibák, valamint a bevezetése hatványozást és egy új módszert prototípus táblák, a 7 th  kiadás közzé 2016. június.

Az ECMA-262 szabvány jelenlegi kiadása a 11. kiadás, amely 2020 júniusában jelent meg.

Biztonság

A JavaScript-nek és a HTML / XML- oldalak DOM- struktúrájának vannak bizonyos biztonsági rései. Ennek oka, hogy a rosszindulatú szkriptek elrejthetik a weboldal kódját, és a webfelhasználó célszámítógépén futtathatók.

A webböngésző gyártói két korlátozással próbálják csökkenteni ezt a kockázatot:

  • Az egyik az, hogy ezeket a szkripteket a többi adattól ( homokozótól ) elkülönített térben futtassuk, amelyben csak az internettel kapcsolatos műveletek hajthatók végre (egérmozgások, pixelek megjelenítése, kommunikáció), a fájlrendszerhez való hozzáférés nélkül.
  • A második az, hogy a szkripteket csak az azonos eredetű házirend korlátozásain belül futtassuk  : ezt szem előtt tartva egy webhelynek nem szabad hozzáférnie olyan információkhoz, mint a felhasználónevek és jelszavak, vagy más látogatott webhelyekről kapott sütik.

A JavaScript biztonsági rései gyakran sértik e két elv legalább egyikét.

A JavaScript nyelvének egyes részhalmazai, például a JavaScript - ADsafe vagy a Secure ECMAScript (SES) nagyobb biztonságot nyújtanak, különösen a harmadik felek által létrehozott szkriptek (beleértve a hirdetéseket is) esetében. A Caja egy másik szoftver harmadik féltől származó JavaScript és HTML biztonságos beágyazására és izolálására.

A tartalombiztonsági irányelv az elsődleges módszer annak biztosítására, hogy csak megbízható parancsfájlokat futtassanak egy weboldalon. A Meltdown egy JavaScript-től független biztonsági rés, amelyet különösen a JavaScript-ben lehet kihasználni.

Programozási koncepciók

A JavaScript célja az objektumok számítógépes értelemben vett egyszerű kezelése , amelyet egy gazda alkalmazás biztosít. Például egy webböngészőben egy javascriptben írt szkript használható interaktív vagy dinamikus érintés hozzáadásához egy alkalmazáshoz (oldalhoz vagy webhelyhez), amely egyébként rögzített statikus oldal lenne. A Javascript nyelv lehetővé teszi például parancsfájlok írását egy bekezdés, kép vagy felugró ablak megjelenítéséhez vagy elrejtéséhez, a felhasználó interakcióinak megfelelően, vagy tájékoztatja a szervert az oldal olvasásával töltött időről.

Bonjour Monde

JavaScript nyelvű szkriptben lehetőség van a hello world szöveg megjelenítésére az alkalmazás hibakereső konzolján. Ezt a fejlesztők felhasználhatják a fejlesztési szakaszban. :

window.console.log('Hello world'); window.console.exp(hello world) // ou global.console.log('Hello world'); window.console.log(hello world)

A böngésző gazda alkalmazás, konzol egyik módszer a globális ablak objektumot . Más gazdagép-alkalmazásokban, például a Node.js- ben a globális objektum globális . Mivel a globális objektum metódusai előtag nélkül érhetők el, az ablak és a globális opcionális.

A szintaxis

console.log('Hello world');

ezért pontosan ugyanaz az eredmény lesz, amellett, hogy kompatibilis minden környezetben.

használat

A JavaScript-kódnak globális objektumra van szüksége ahhoz, hogy deklarációkat ( változókat és függvényeket) csatoljon hozzá, mielőtt utasításokat futtatna. A legismertebb a helyzet, hogy az ablak objektum összefüggésben szerzett egy internetes oldalon. Más környezetek is lehetségesek, beleértve az Adobe által biztosítottat vagy a Node.js környezetet (lásd lent: Egyéb felhasználások).

Egy weboldalon

A JavaScript kód közvetlenül integrálható a weboldalakba , és az ügyfél munkaállomásán futtatható . Ezután a webböngésző kezeli a parancsfájloknak nevezett programok végrehajtását.

Általában a JavaScript-et használják a HTML- űrlapokba beírt adatok vezérlésére vagy a HTML-dokumentummal való interakcióra a böngésző által biztosított Document Object Model felületen keresztül (ezt néha dinamikus HTML-nek vagy DHTML-nek is nevezik ). Dinamikus alkalmazások, átmenetek, animációk létrehozására vagy reaktív adatok manipulálására is használják ergonómiai vagy kozmetikai célokra.

A JavaScript nem korlátozódik a HTML dokumentumok manipulálására, hanem SVG , XUL és más XML nyelvjárások manipulálására is használható .

Inkompatibilitás

A Netscape és a Microsoft (az Internet Explorer JScript-jével a 9-es verzióig) kifejlesztették ennek a nyelvnek a saját változatát, amelyek mindegyike szinte teljes mértékben támogatja az ECMAScript szabványt, de további és inkompatibilis funkciókkal rendelkezik, amelyeket ritkán használnak az oldalak programozásakor. Mégis a JavaScript szkriptek jelentik a nehézségek forrását. Gyakrabban a böngészők által biztosított objektummodellek ( DOM ) különböző verzióinak támogatásából adódnak , mint a nyelvi hordozhatóság problémáiból (a különféle megvalósítások viszonylag jól tiszteletben tartják az ECMAScript szabványt).

Dinamikusan ellenőrizni, hogy egy objektum (az értelmezés során használt JavaScript verzióban) valóban rendelkezik-e módszerrel, gyakran olyan konstrukciót használunk, mint:

if (monObjet.methode && typeof monObjet.methode === 'function') { monObjet.methode(); }

Így ellenőrizzük, hogy a myObjet valóban rendelkezik-e olyan módszerrel , amelyet aztán használhatunk. Leggyakrabban, ha a böngésző nem támogatja a módszert a myObject , hogy támogatja a hasonló módszerrel method2 , és tudjuk majd alkalmazkodni a JavaScript kódot a böngészőnek, hogy végrehajtja:

if (typeof monObjet.methode === 'function') { monObjet.methode(); } else if (typeof monObjet.methode2 === 'function') { monObjet.methode2(); }

Egy másik módszer a szerver oldalon ellenőrizni az ügyfél által használt böngészőt és elküldeni a megfelelő kódot. Ez azonban nem tanácsos, mivel sokkal jobb, ha közvetlenül teszteljük egy függvény, tulajdonság stb. Létét, viselkedését  stb. ahelyett, hogy a böngésző észlelésén alapuló feltételezéseket tenne.

Ajax

Az Ajax (angolul Asynchronous JavaScript And XML ) olyan technikák összessége, amelyek elválasztják a böngésző és a webszerver közötti adatcserét a weboldal megjelenítéséről, amely lehetővé teszi a weboldalak tartalmának módosítását anélkül, hogy feltöltenék őket. Az XMLHTTPRequest JavaScript objektumnak köszönhetően ez a módszer lehetővé teszi HTTP kérések készítését a webszerverről a webböngészőből, valamint a webszerverről érkező HTTP válaszok feldolgozását a weboldal tartalmának módosítása érdekében. A válasz általában XML formátumban történt, amelyet most inkább JSON formátum vált fel, amelynek az az előnye, hogy natív a JavaScript-ben. A szkript manipulálja a DOM objektumok halmazát, amelyek a weboldal tartalmát képviselik. Az XMLHTTPRequest , az XML és a DOM technológiákat 1995 és 2005 között adták hozzá a webböngészőkhöz. Az Ajax módszer lehetővé teszi gazdag internetes alkalmazások létrehozását , nagyobb kezelhetőséget és kényelmet kínálva; ez a Web 2.0 mozgalom egyik kulcsfontosságú témája .

JSON

A JSON ( JavaScript Object Notation ) egy olyan formátum, amely a JavaScript objektumok jelölését használja a strukturált információk továbbítására, kompaktabb módon és közelebb a programozási nyelvekhez , mint az XML.

A DOM megléte és az E4X (lásd alább) nemrégiben bevezetett JavaScript nyelvi specifikáció ellenére a JSON továbbra is a legegyszerűbb módja az adatok elérésének, mivel minden JSON adatfolyam nem más, mint egy sorosított JavaScript objektum. Sőt, a JSON a JavaScript-hez fűződő történelmi (és technikai) kapcsolata ellenére is strukturált adatformátum marad, és minden programnyelv könnyen használható.

2009 óta a böngészők elkezdték integrálni a JSON formátum natív támogatását, amely megkönnyíti annak kezelését, biztonságát (a JSON karaktersorozatban található rosszindulatú szkriptek kiértékelésével szemben) és a feldolgozási sebességet. Így a Firefox és az IE böngészők integrálják a 3.5, illetve a 8. verzióból.

Példa JSON-ra:

{ "clef1": "valeur", "clef2": 12345, "clef3": true, "clef4": { "clef5": "valeur" } }

A struktúrát kulcsok / értékek rendezik. A kulcsoknak kettős idézőjelben kell lenniük. Az értékek a következők lehetnek:

  • egy karakterlánc (karakterlánc dupla idézőjelek között)
  • egy szám
  • logikai érték (igaz vagy hamis igaz vagy hamis)
  • kulcs / érték struktúra

Az érvényes JSON-nak nem lehet megjegyzése. Vannak online JSON-hitelesítők.

Egyéb felhasználások

Webkiszolgálón

A JavaScript programozási nyelvként is használható egy HTTP szerveren, például olyan nyelveken, mint a PHP , az ASP stb. Ezenkívül a CommonJS projekt úgy működik, hogy megadjon egy ökoszisztémát a JavaScript számára a böngészőn kívül (például a szerveren vagy a natív asztali alkalmazásokhoz). A projektet Kevin Dangoor indította el2009. január. A CommonJS projekt nem áll kapcsolatban az ECMAScript-en dolgozó Ecma International TC39 csoporttal, de a TC39 néhány tagja részt vesz a projektben.

Történelmileg JavaScript javasolták szervereken Netscape később forgalmazott Sun Microsystems nevek alatt iPlanet és a Sun ONE , de JScript lehet használni a szervereken Internet Information Services származó Microsoft . JScript is fel lehet használni, hogy script a Microsoft Windows platformon keresztül Windows Scripting Host (WSH).

Vannak független és nyílt forráskódú szerver implementációs projektek is a JavaScript-ben. Közülük megkülönböztethetjük a Node.js-t , egy sokoldalú hálózati alkalmazás-fejlesztő platformot, amely a JavaScript-motor V8 és CommonJS specifikációira épül .

Egyéb média

Az Adobe Flashben használt ActionScript szintén az ECMAScript megvalósítása. Lehetővé teszi az animáció objektumként tekintett összes elemének kezelését. A JavaScript használható más Adobe alkalmazások ( Photoshop , Illustrator stb.) Szkriptelésére, amely platformfüggetlen parancsfájlokat (Microsoft Windows, Apple OSX, Linux stb.) Tesz lehetővé.

Végül a JavaScriptet a Mozilla fejlesztői platformján használják , amelyen számos szoftverprogram, például webböngésző alapul , a felhasználói felülettel és a belső kommunikációval kapcsolatos feladatokhoz (például: a Firefox és a Thunderbird kiterjesztéseket XPI fájlok alapján telepítik JavaScript használatával. Lásd még: Prefs.js ).

2004 óta a Max / MSP grafikus programozási környezet js objektumát arra használják, hogy ablakot nyissanak a JavaScript programozáshoz, még egy Max / MSP programon belül is .

Az ImageJ és a CaRMetal szoftverek JavaScript konzolokkal vannak felszerelve, amelyek lehetővé teszik számukra a szkriptek grafikus kontextusban történő írását. Az Algobox a JavaScript- et használja a funkcióinak szintaxisában. A H5P a HTML5 és a Javascript használatával megkönnyíti az interaktív online tartalom létrehozását.

A JavaScriptet a BIFS- tartalmakban is használják események feldolgozásához . Ehhez a BIFS specifikáció egy Script csomópontot biztosít az ECMAScript beépítésére.

Az OpenOffice.org irodai csomag lehetővé teszi a JavaScript használatát makró nyelvként.

A JavaScript héjban vagy Vista modulokkal együtt is használható .

Az SVG vektorgrafikai formátum magában foglalja az ECMAscript nyelvet, és interaktív grafikákat hoz létre közvetlenül a böngészőben.

Végül a JavaScriptet a Qt grafikus könyvtár QML-jének javítására is használják .

A nyelv sajátosságai

Azonosítók összekapcsolása

A JavaScript-ben az összes kifejezés (azonosítók, literálok, operátorok és azok operandusai) referencia típusúak (például a Pythonban és a Ruby-ban , de ellentétben a C ++ , Java , C # , Swift és OCaml értékekkel, amelyek szintén rendelkeznek értéktípusú kifejezésekkel ), vagyis mondani, hogy értékelésük nem közvetlenül adatot hoz létre, hanem hivatkozást adatra. A hivatkozást a kifejezés referensének nevezzük, és megkapjuk a hivatkozott kifejezést.

A JavaScript-ben a változó hozzárendelése módosítja referenciáját, más szavakkal, a változót egy másik adathoz köti: a változó kötésében bekövetkezett változásról beszélünk (angolul változó újracsatolása ).

var maVariable1 = 0; // lie `maVariable1` à une donnée de valeur 0 var maVariable2 = maVariable1; // lie `maVariable2` à la donnée liée à `maVariable1` maVariable1++; // équivalent à `maVariable1 = maVariable1 + 1;`, relie `maVariable1` à une nouvelle donnée de valeur maVariable1 + 1 (affectation) juin alert(maVariable1); // affiche 1 alert(maVariable2); // affiche 0 var maVariable3 = [1, 2, 3]; // lie `maVariable3` à une donnée de valeur [1, 2, 3] var maVariable4 = maVariable3; // lie `maVariable4` à la donnée liée à `maVariable3` maVariable3 = [4, 5, 6]; // relie `maVariable3` à une nouvelle donnée de valeur [4, 5, 6] (affectation) alert(maVariable3); // affiche [4, 5, 6] alert(maVariable4); // affiche [1, 2, 3] var maVariable5 = [1, 2, 3]; // lie `maVariable5` à une donnée de valeur [1, 2, 3] var maVariable6 = maVariable5; // lie `maVariable6` à la donnée liée à `maVariable5` maVariable5.push(4); // modifie la donnée liée à `maVariable5` et `maVariable6` alert(maVariable5); // affiche [1, 2, 3, 4] alert(maVariable6); // affiche [1, 2, 3, 4]

A változók lexikai köre

A változó lexikális hatóköre a program azon része, ahol érvényes az azonosítója és adatai közötti kapcsolat. A JavaScriptben a változó lexikális hatóköre kétféle lehet, a deklaráláshoz használt kulcsszótól függően:

  • var : a függvény (vagy a globális tér) szintjén, ahol deklarálva van (mint a Python , Ruby esetében );
  • letvagy const(bevezetve az ECMAScript 6-ba): azon blokkszinten, ahol deklarálva van (például a C ++ , Java , C # esetében ) - egy funkció egy adott blokk.
// 1. Déclaration dans un bloc if (true) { // début du bloc var maVariable1; // déclaration de la variable let maVariable2; // déclaration de la variable const maVariable3; // déclaration de la variable } // fin du bloc mais pas de la portée de maVariable1 alert(maVariable1); // ne soulève pas d'erreur alert(maVariable2); // erreur : la variable est hors de sa portée alert(maVariable3); // erreur : la variable est hors de sa portée // 2. Déclaration dans une fonction function maFunction() { // début de la fonction var maVariable4; // déclaration de la variable let maVariable5; // déclaration de la variable const maVariable6; // déclaration de la variable } // fin de la fonction et de la portée des variables alert(maVariable4); // erreur : la variable est hors de sa portée alert(maVariable5); // erreur : la variable est hors de sa portée alert(maVariable6); // erreur : la variable est hors de sa portée

Egy változó hozzárendelhető vagy elrejthető a függvény (vagy a globális tér) gyermekfunkciójával, ahol deklarálva van:

var maVariable1 = 0; // définition de la variable parente // 1. Affectation function maFonction1() { // fonction enfant maVariable1 = 1; // affectation de la variable parente } alert(maVariable1); // affiche 0 maFonction1(); // affecte la variable parente alert(maVariable1); // affiche 1 // 2. Masquage var maVariable2 = 0; // définition de la variable parente function maFonction2() { // fonction enfant var maVariable2; // déclaration de la variable enfant masquant la variable parente maVariable2 = 1; // affectation de la variable enfant } alert(maVariable2); // affiche 0 maFonction2(); alert(maVariable2); // affiche 0

Változó nyilatkozat

A JavaScript-ben, függetlenül attól, hogy egy változó hol van deklarálva a lexikai hatókörében, a változó a lexikai hatókörének értékelése elején jön létre .

A kulcsszóval deklarált változók létrehozásukkor varszintén inicializálódnak az értékre undefined, ezért lexikális hatókörük kezdetétől hozzáférhetők. A változó emeléséről beszélünk ( angolul a változó emelése ), mert ez úgy történik, mintha a változó deklarációja felment volna a lexikai hatókörének kezdetéig:

alert(maVariable); // affiche undefined var maVariable = 0; alert(maVariable); // affiche 0

A kulcsszóval letvagy const(ECMAScript 6) deklarált változók nincsenek inicializálva, ezért a deklarálásuk előtt nem érhetők el. Ha a kulcsszóval deklarált változónak letnincs inicializálója, akkor undefineda deklaráció kiértékelése során az értékre inicializálják , ellenkező esetben a deklaráció kiértékelése során az inicializálóval inicializálják. Ha a kulcsszóval deklarált változónak constnincs inicializálója, akkor hiba lép fel a deklaráció értékelésekor, ellenkező esetben a deklaráció kiértékelésekor az inicializálóval inicializálják:

// 1. Avec initialiseur alert(maVariable1); // erreur : accès impossible avant l'initialisation alert(maVariable2); // erreur : accès impossible avant l'initialisation let maVariable1 = 5; const maVariable2 = 8; alert(maVariable1); // affiche 5 alert(maVariable2); // affiche 8 // 2. Sans initialiseur alert(maVariable3); // erreur : accès impossible avant l'initialisation alert(maVariable4); // erreur : accès impossible avant l'initialisation let maVariable3; const maVariable4; // erreur : initialisation manquante alert(maVariable3); // affiche undefined alert(maVariable4); // erreur : initialisation manquante

Ezenkívül a JavaScript megengedi ugyanazon változó lexikális terjedelmében történő újradeklarálását, de csak a következő kulcsszóval var :

var maVariable = 2; var maVariable = 9;

Globális változók

A JavaScript-ben többféle módon lehet deklarálni a globális változót , és egyesek interakcióba lépnek a globális objektummal (amelyet windowböngészőkben neveznek meg):

var maVariable1 = 0; // propriété ou méthode de l'objet global qui ne peut pas être détruite par l'opérateur delete let maVariable2 = 0; // pas une propriété ou méthode de l'objet global const maVariable3 = 0; // pas une propriété ou méthode de l'objet global maVariable4 = 0; // propriété ou méthode de l'objet global qui peut être détruite par l'opérateur delete window.maVariable5 = 0; // propriété ou méthode de l'objet global qui peut être détruite par l'opérateur delete this.maVariable6 = 0; // propriété ou méthode de l'objet global qui peut être détruite par l'opérateur delete

A deklaráció nélkül inicializált változót globális változóként kezeljük:

function maFonction() { maVariable = 5; } maFonction(); alert(maVariable); // affiche 5

Névtelen funkciók

Az anonim függvények , amint a nevük is mutatja, olyan funkciók, amelyek nem viselnek nevet:

setTimeout(function () { alert('Trois secondes se sont écoulées.'); }, 3000);

Ezt a függvény paramétereként adják meg setTimeout, amely lehetővé teszi az időtartam meghatározását az üzenet megjelenítése előtt.

Lexikai zárások

A lexikális környezet az érvényes változók halmaza a program egy részében. Ez a belső lexikai környezetből (a helyi változók) és a külső lexikai környezetre (a nem helyi változók) való hivatkozásból áll.

A lexikális bezárás ( angolul a lexikális bezárás ) a külső lexikális környezettel rendelkező függvény, vagyis az összes nem lokális változó, amelyet vagy érték alapján rögzítettek (a megőrzés minden más, nem helyi változókhoz kapcsolt adatelemének másolata), vagy a referencia (tartva a hivatkozás minden egyes adathoz kapcsolódó non-lokális változók). Mint a JavaScript-ben, az összes változó referencia típusú (lásd: Azonosító összerendelése ), a JavaScript csak hivatkozással történő rögzítést használ - amely a C ++ 11-ben megfelel a szintaxisnak [&](…) { … };-, és a nem helyi változók élettartamát. kiterjesztésre kerül a függvény élettartamára - ami a C ++ 11 esetében nem így van, a rögzítés típusától függetlenül:

function maFonction() { var maVariable = 4; // variable parente return function () { alert(maVariable); } } var maFermeture = maFonction(); // capture de la variable parente par référence maFermeture(); // affiche 4

Azonnal meghívott funkciók kifejezései

Amíg ECMAScript 6, JavaScript nem natív ajánlatot blokk szintű változó körök (nem kulcsszavak letvagy const), vagy modulokat . A globális tér szennyezésének elkerülése érdekében az egyik módszer az volt, hogy kódját beillesztette egy függvénybe, hogy támaszkodjon a változók hatókörére, amely a függvény szintjén zajlik a JavaScript-ben, majd ezt követően azonnal meghívja ezt a függvényt. A két lépés kombinálásával (a függvény meghatározása és meghívás), és nem hozzáadva további függvénynevet a globális térbe, a nyelv lehetővé teszi az azonnal meghívott funkciók kifejezéseit (EFII; angolul azonnal meghívott függvény-kifejezések , IIFE).

Az ilyen típusú kifejezésekhez több szintaxis is lehetséges, a leggyakoribbak:

  • (function (…) { … }(…));(szintaxist Douglas Crockford ajánlotta olvashatósága érdekében);
  • (function (…) { … })(…);

A ()végén meghívott operátor lehetővé teszi a funkció azonnali végrehajtását. A félkövér zárójelek azt mondják az elemzőnek, hogy tartalmaznak kifejezést, mert JavaScript-ben a zárójelek nem tartalmazhatnak deklarációt. Egyébként a legtöbb helyzetben a kulcsszót functionfüggvénydeklarációként kezeljük, nem pedig függvénykifejezésként. A függvénykifejezés kényszerítésére más módon is van lehetőség:

  • !function (…) { … }(…);
  • ~function (…) { … }(…);
  • -function (…) { … }(…);
  • +function (…) { … }(…);

Olyan összefüggésekben, ahol kifejezés várható, nem szükséges félkövér zárójelet használni:

  • var maVariable = function (…) { … }(…);
  • true && function (…) { … }(…);
  • 0, function (…) { … }(…);

Az azonnal meghívott függvény-kifejezések fontos felhasználása a modulok felépítése. A modulok lehetővé teszik a tulajdonságok és a módszerek gyűjtését egy névtérben, és bizonyos tagok priváttá tételét:

var compteur = (function () { var i = 0; // propriété privée return { // méthodes publiques obtenir: function () { alert(i); }, mettre: function (valeur) { i = valeur; }, incrementer: function () { alert(++i); } }; })(); // module compteur.obtenir(); // affiche 0 compteur.mettre(6); compteur.incrementer(); // affiche 7 compteur.incrementer(); // affiche 8 compteur.incrementer(); // affiche 9

Prototípusok

A prototípusok olyan objektumok, amelyeket egy névfeloldási hiba során használnak. Ez a mechanizmus egyfajta öröklés: az öröklés prototípusa. A JavaScript-ben minden objektum rendelkezik prototípussal, amely a módszerrel Object.getPrototypeOf(vagy __proto__az ECMAScript 6-ban szabványosított, a böngészők közötti kompatibilitás biztosítása érdekében szabványosított, de nem ajánlott) hozzáférhető. Ezenkívül az operátort arra newhasználják, hogy a konstruktor függvény meghívását olyan objektummá (példányosítássá) alakítsák át, amelynek prototípusa megegyezik prototypea konstruktor függvény tulajdonságával :

function MonConstructeur() { this.maPropriete1 = 3; } var monInstance = new MonConstructeur(); alert(monInstance.maPropriete1); // affiche 3 alert(Object.getPrototypeOf(monInstance) === MonConstructeur.prototype); // affiche true MonConstructeur.prototype.maPropriete2 = 5; alert(monInstance.maPropriete2); // affiche 5

A MonConstructeur( monInstanceitt) bármely példányának prototípusa megegyezik MonConstructeur.prototype. A MonConstructeur( monInstance.maPropriete1és monInstance.maPropriete2itt) példány tulajdonságának vagy módszerének használatakor , ha a példánynak nincs meg a keresett tulajdonság vagy módszer, a keresés a példány prototípusában folytatódik ( MonConstructeur.prototypeitt). Ha a keresés ezzel az objektummal sem sikerül, akkor a keresés az objektum prototípusában folytatódik, és így tovább, amíg el nem éri az első konstruktor funkciót. Ha a keresés még mindig kudarcot vall, mivel ez az első konstruktor függvény függvény, ezért a Functionnyelv konstruktor függvény példánya , a keresés prototípusában folytatódik, amely megegyezik Function.prototype. Ha a keresés ismét kudarcot vall, Function.prototypeobjektumként és ezért a nyelvalkotó függvény példányaként Object, a keresés prototípusában folytatódik, amely megegyezik Object.prototype. Ha a keresés ezúttal kudarcot vall, mert az Object.prototypeegyenlő prototípusa null, a keresés leáll, és a JavaScript névfeloldási hibát generál. Ez a keresési mechanizmus megy keresztül az úgynevezett prototípusok láncán .

A kezelői kód instanceOfjól szemlélteti ezt a mechanizmust. A instanceOf B(vagy ekvivalensen instanceOf.call(A, B):) visszaadja, trueha Avan egy példánya B, vagyis ha B.prototypemegtalálható a prototípus láncában A, és falseegyébként:

function instanceOf(f) { var o = this; while (o !== null) { if (Object.getPrototypeOf(o) === f.prototype) { return true; } o = Object.getPrototypeOf(o); } return false; }

Ezenkívül Object.createaz ECMAScript 5-ben bevezetett módszer lehetővé teszi a konstruktor függvények, azok tulajdonságainak prototypeés az operátor közvetlen használatának elkerülését new, hogy csak objektumokkal dolgozzon. A módszer használata jelentősen leegyszerűsíti a kód összetettségét, ezért ajánlott. A módszert Object.createaz határozza meg

if (typeof Object.create !== 'function') { Object.create = function (o) { function F() {} F.prototype = o; return new F(); }; }

Ezután az előző példa átírható

var MonObjet = { function initialiser() { this.maPropriete1 = 3; } } var monInstance = Object.create(MonObjet); monInstance.initialiser(); alert(monInstance.maPropriete1); // affiche 3 MonObjet.maPropriete2 = 5; alert(monInstance.maPropriete2); // affiche 5

Az utasítások szétválasztása

A C , minden állítás végén egy pontosvessző . Ez a gyakorlat a pontosvesszőt számos nyelvben követelményté tette a C szintaxis ihlette.

A JavaScript rugalmasabb, lehetővé teszi a sor végét, hogy implicit módon jelezze az utasítás végét. A cél a nyelvhasználat megkönnyítése a számítógépes programozásban járatlan emberek számára . De ez a rugalmasság váratlan hatásokat idéz elő:

return true;

Az elemző ezt két utasításként érti:

return; true;

Azon funkciókifejezések, amelyek azonnal meghívásra kerülnek, amikor a programozó implicit utasításvégekre támaszkodik, szintén ilyen problémákkal találkoznak a zárójelek használatával:

maVariable1 = maVariable2 + maVariable3 (function () { // code })()

úgy kezelik

maVariable1 = maVariable2 + maVariable3(function () { /* code */ })();

A fejlett JavaScript programozási könyvek figyelmeztetnek az utasítások végi automatikus levonásának váratlan hatásaira, és tanácsot adnak pontosvessző írására az egyes utasítások végén, ami nem akadályozza meg a pontosvessző elfelejtésekor jelentkező meglepetéseket, különösen akkor, ha a kódtömörítéshez a kocsi visszatérésének eltávolítása szükséges.

Függelékek

Kapcsolódó cikkek

Külső linkek

Megjegyzések és hivatkozások

  1. Douglas Crockford , a Yahoo! Crockford a JavaScript-en - 2. fejezet: És akkor volt JavaScript , csak a Java, a Scheme és az Önre korlátozódik, mint a JavaScript közvetlen hatása
  2. David Flanagan , JavaScript: A végleges útmutató , 6. th  ed. , P.  1

    "A JavaScript annak a technológiának a triád része, amelyet minden webfejlesztőnek meg kell tanulnia: HTML a weboldalak tartalmának megadásához, CSS a weboldalak megjelenítésének megadásához és a JavaScript a weboldalak viselkedésének meghatározásához. "

  3. (in) "  A JavaScript használatának statisztikája webhelyekhez, 2018. március  " a w3techs.com webhelyen (elérhető: 2018. október 3. )
  4. (in) "  Bevezetés a JavaScriptbe  " a javascript.info oldalon (elérhető: 2020. július 20. )
  5. "  Modulecounts  " a www.modulecounts.com címen (hozzáférés : 2017. augusztus 5. )
  6. (en) http://wiki.commonjs.org/wiki/CommonJS
  7. (in) Node.js Foundation , "  Node.js  " a Node.js oldalon (hozzáférés: 2017. augusztus 5. )
  8. (in) Liam Tung , "  Deno 1.0: A Node.js JavaScript futásidejű gyártóknak új programozási nyelvük van a gépírás számára  " a ZDNet-en (hozzáférés: 2020. július 20. )
  9. TechVision: A hálózat újítói: Brendan Eich és a JavaScript
  10. (in) HÁLÓZAT ÉS A NAP HIRDETI A JAVASCRIPTET, A VÁLLALKOZÁSI HÁLÓZATOK ÉS AZ INTERNET NYITOTT KERESZTEN KÖZÖTTI OBJEKTUMOK NYELVÉT
  11. "  Mi a különbség a Java és a JavaScript között?" - Quora  ” , a fr.quora.com oldalon (hozzáférés : 2017. augusztus 5. )
  12. (in) "  Védjegyes dokumentumok visszakeresése és állapota  " a tsdr.uspto.gov oldalon (elérhető: 2018. június 28. )
  13. „Sun védjegyek” (2010. május 28-i verzió az Internet Archívumban ) ,2010. május 28
  14. "  Standard ECMA-262  " , www.ecma-international.org (hozzáférés : 2019. október 2. )
  15. "  A JavaScript biztonságossá tétele a reklámozásban  " , ADsafe (hozzáférés : 2013. május 26. )
  16. "  Secure ECMA Script (SES)  " , Code.google.com (hozzáférés : 2013. május 26. )
  17. "  Miért tekinthető jobbnak a console.log (), mint az alert ()?  » , A stackoverflow.com webhelyen (megtekintve : 2017. augusztus 5. )
  18. (hu-USA) „  Window  ” , a Mozilla Developer Network-től (hozzáférés : 2017. augusztus 5. )
  19. (in) "  Globális objektumok | Node.js v8.2.1 Documentation  ” , a nodejs.org oldalon (hozzáférés : 2017. augusztus 5. )
  20. (in) "  IEBlog  " az msdn.com webhelyen (hozzáférés: 2020. szeptember 29. ) .
  21. Lásd: Bevezetés a JavaScript héjba
  22. (a) Ben Alman , "  Azonnal-hivatkozott Function Expression (IIEF)  " on benalman.com ,2010. november 15(megtekintve 2016. május 14-én )
  23. (in) Douglas Crockford , "  A JavaScript programozási nyelvének kódkonvenciói  " a javascript.crockford.com címen (hozzáférés: 2016. május 14. )
  24. Ezt a példát a 25. oldalon adta: JavaScript - A végleges útmutató , negyedik kiadás, David Flanagan, O'Reilly Media kiadások , Sebastopol, Kalifornia.