Javascript | ||
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 .
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.
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éseA 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 szerintSzerkeszté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éseA 3 -én kiadása a ECMA-262 szabvány bevezette:
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 szakaszA 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ókAz 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ásBá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özA 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.
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:
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.
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.
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.
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).
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ásA 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.
AjaxAz 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 .
JSONA 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:
Az érvényes JSON-nak nem lehet megjegyzése. Vannak online JSON-hitelesítők.
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édiaAz 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 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ó 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:
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 0A 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 0A 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 manquanteEzenkí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;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 deleteA 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 5Az 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.
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 4Amí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:
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:
Olyan összefüggésekben, ahol kifejezés várható, nem szükséges félkövér zárójelet használni:
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 9A 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 5A 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 5A 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.
"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. "