Javascript

javascript
?
Algemene informatie
Algemene extensies	.js
Paradigma	Multiparadigma , functioneel programmeren , ​prototype-gebaseerd programmeren , imperatief , geïnterpreteerd ( scripting )
Verscheen in	4 december 1995
Ontworpen door	Netscape Communications , Mozilla Foundation
Laatste stabiele versie	ECMAScript 2021 (1 juni 2021 (1 jaar, 4 maanden en 15 dagen))
type systeem	zwak, dynamisch, eend
implementaties	SpiderMonkey , Neushoorn , KJS , JavaScriptCore , V8 , Chakra .
dialecten	ECMAScript
beïnvloed door	Java , Perl , Zelf , Python , C , Schema
heeft beïnvloed	ObjectiveJ, JScript .NET, TIScript

JavaScript (vaak afgekort als JS ) is een geïnterpreteerde programmeertaal , dialect van de ECMAScript -standaard . Het wordt gedefinieerd als objectgeoriënteerd , op prototypes gebaseerd , imperatief, zwak getypt en dynamisch .

Het wordt voornamelijk client-side gebruikt , geïmplementeerd als onderdeel van een webbrowser die verbeteringen aan de gebruikersinterface en dynamische webpagina's en server -side JavaScript ( Server-side JavaScript of SSJS ) mogelijk maakt. Het gebruik ervan in toepassingen buiten het web , bijvoorbeeld in PDF -documenten , desktoptoepassingen (meestal widgets ) is ook aanzienlijk.

Sinds 2012 ondersteunen alle moderne browsers ECMAScript 5.1, een versie van JavaScript, volledig. Oudere browsers ondersteunen minimaal ECMAScript 3. De zesde editie werd uitgebracht in juli 2015. ]

JavaScript is ontworpen met een syntaxis vergelijkbaar met C++ en Java , ​ hoewel het namen en conventies overneemt van de Java-programmeertaal. Java en JavaScript hebben echter verschillende semantiek en doeleinden. Hun relatie is puur commercieel, na de aankoop van de maker van Java (Sun Microsystems) van Nestcape Navigator (maker van LiveScript) en de naamswijziging van de programmeertaal.

Alle moderne browsers interpreteren JavaScript-code die is ingesloten in webpagina's. Voor interactie met een webpagina wordt de JavaScript-taal geleverd met een implementatie van het Document Object Model (DOM). Javascript is de enige programmeertaal die browsers native begrijpen.

Traditioneel werd het gebruikt in HTML -webpagina's om bewerkingen uit te voeren en alleen binnen het kader van de clienttoepassing , zonder toegang tot serverfuncties . Het wordt momenteel veel gebruikt om informatie van de server te verzenden en te ontvangen, samen met de hulp van andere technologieën zoals AJAX . JavaScript wordt geïnterpreteerd door de user-agent terwijl de instructies samen met de HTML -code worden gedownload .

Sinds de release van de ECMAScript 1-standaard in juni 1997 zijn er versies 2, 3 en 5 geweest, die tegenwoordig het meest worden gebruikt (versie 4 is verwijderd ). In juni 2015 werd de ECMAScript 6-versie gesloten en gepubliceerd ]

Geschiedenis

JavaScript

JavaScript is oorspronkelijk ontwikkeld door Brendan Eich van Netscape onder de naam Mocha , die later werd omgedoopt tot LiveScript en uiteindelijk JavaScript werd. De naamswijziging viel ongeveer samen met de tijd dat Netscape in december 1995 in versie 2002 Java-technologie-ondersteuning aan zijn Netscape Navigator-webbrowser toevoegde . De naamgeving veroorzaakte verwarring, waardoor de indruk werd gewekt dat de taal een uitbreiding van Java is. als marketingstrategie voor Netscape om prestige te verwerven en te innoveren op het gebied van nieuwe webprogrammeertalen. ]

"JAVASCRIPT" is een gedeponeerd handelsmerk van Oracle Corporation . Het wordt onder licentie gebruikt door producten die zijn gemaakt door Netscape Communications en huidige entiteiten zoals de Mozilla Foundation . ]

Microsoft noemde zijn dialect van JavaScript " JScript ", om brandingproblemen te voorkomen. JScript is overgenomen in versie 3.0 van Internet Explorer, uitgebracht in augustus 1996, en bevatte Effect 2000- ondersteuning voor datumfuncties, een afwijking van die op dat moment. De dialecten lijken misschien zo op elkaar dat de termen "JavaScript" en "JScript" vaak door elkaar worden gebruikt, maar de JScript-specificatie is in veel opzichten onverenigbaar met de ECMA-specificatie.

Om deze onverenigbaarheden te voorkomen, heeft het World Wide Web Consortium de Document Object Model (DOM, of Document Object Model in het Spaans) standaard ontworpen, die Konqueror , versies 6 van Internet Explorer en Netscape Navigator , Opera versie 7, Mozilla Application Suite en Mozilla Firefox bevat. vanaf de eerste versie. ^{[ citaat nodig ]}

In 1997 stelden de auteurs JavaScript voor om als standaard te worden aangenomen door de European Computer Manufacturers' Association ECMA , die ondanks zijn naam niet Europees maar internationaal is, gevestigd in Genève. In juni 1997 werd het aangenomen als ECMA-standaard, onder de naam ECMAScript . Kort daarna ook als ISO- norm .

JavaScript aan de serverzijde

Netscape introduceerde een server-side scripting- implementatie met Netscape Enterprise Server , uitgebracht in december 1994 (kort na de release van JavaScript voor webbrowsers). ​ Vanaf het midden van de jaren 2000 is er een wildgroei aan server-side JavaScript-implementaties geweest. Node.js is een van de opmerkelijke voorbeelden van server-side JavaScript, dat wordt gebruikt in grote projecten. ]

Latere

JavaScript is een van de meest populaire en meest gebruikte programmeertalen op internet geworden. In het begin keurden veel ontwikkelaars de taal echter af omdat de beoogde doelgroep onder meer bestond uit uitgevers van artikelen en andere hobbyisten. De komst van Ajax bracht JavaScript weer op de voorgrond en trok de aandacht van vele andere programmeurs. Als gevolg hiervan was er een proliferatie van een reeks frameworks en bibliotheken van algemene strekking, verbeterde JavaScript-programmeerpraktijken en toegenomen gebruik van JavaScript buiten webbrowsers , zoals te zien is met de proliferatie van JavaScript-omgevingen aan de webkant. server . In januari 2009 werd het CommonJS- project gelanceerd met als doel een bibliotheek te specificeren voor gebruik door algemene taken, voornamelijk voor ontwikkeling buiten de webbrowser. ]

In juni 2015 werd de ECMAScript 6 -standaard gesloten en gepubliceerd ​ met onregelmatige ondersteuning tussen browsers ​ en die JavaScript voorziet van geavanceerde functies die werden gemist en die vaak worden gebruikt in JavaScript. als modules voor code-organisatie, echte klassen voor objectgeoriënteerd programmeren , pijluitdrukkingen, iterators, generatoren of beloften voor asynchrone programmering.

Versie 7 van ECMAScript staat bekend als ECMAScript 2016, en is de nieuwste beschikbare versie, uitgebracht in juni 2016. Het is de eerste versie die een nieuwe jaarlijkse vrijgaveprocedure en ontwikkelingsproces gebruikt. ]

Functies

De volgende functies zijn gemeenschappelijk voor alle implementaties die voldoen aan de ECMAScript-standaard, tenzij u expliciet anders aangeeft.

Dwingend

JavaScript ondersteunt een groot deel van de programmeerstructuur van C (bijvoorbeeld statements if, loops for, statements switch, etc.). Met één kanttekening, gedeeltelijk: in C worden variabelen beperkt tot het blok waarin ze zijn gedefinieerd; JavaScript ondersteunt dit echter niet, aangezien het bereik van variabelen dat is van de functie waarin ze zijn gedeclareerd. Dit verandert met de ECMAScript 2015-release, omdat het ondersteuning toevoegt voor block scoping via het trefwoord . Net als in C maakt JavaScript een onderscheid tussen expressies en statements. Een syntactisch verschil met C is het automatisch invoegen van puntkomma's, dat wil zeggen dat in JavaScript de puntkomma's die eindigen op een zin kunnen worden weggelaten. ] let

Dynamisch

dynamisch typen

Zoals in de meeste scripttalen is het type gekoppeld aan de waarde, niet aan de variabele. Een variabele xkan bijvoorbeeld ooit aan een getal zijn gebonden en later aan een tekenreeks worden teruggekaatst . JavaScript ondersteunt verschillende manieren om het type van een object te controleren, inclusief duck typing . Een manier om erachter te komen is via het trefwoord typeof.

objectief

JavaScript bestaat bijna volledig uit objecten . Objecten in JavaScript zijn associatieve arrays , verbeterd door de opname van prototypes (zie hieronder). Namen van objecteigenschappen zijn sleutels van het type string: obj.x = 10en obj['x'] = 10zijn equivalent, waarbij de puntnotatie syntactische suiker is. Eigenschappen en hun waarden kunnen tijdens runtime worden gemaakt, gewijzigd of verwijderd. De meeste eigenschappen van een object (en die welke zijn opgenomen in de prototypische overervingsketen) kunnen worden opgesomd via de loop-instructie for... in. JavaScript heeft een klein aantal vooraf gedefinieerde objecten zoals Functionen Date.

Runtime-evaluatie

JavaScript bevat de mogelijkheid evalom tijdens runtime uitdrukkingen te evalueren die worden uitgedrukt als tekenreeksen. Om deze reden wordt aanbevolen om evalhet met voorzichtigheid te gebruiken en ervoor te kiezen om de functie JSON.parse()zoveel mogelijk te gebruiken, omdat het veel veiliger kan zijn.

Functioneel

Eersteklas functies

Functies worden vaak eersteklas burgers genoemd; het zijn objecten op zich. Als zodanig hebben ze eigenschappen en methoden, zoals .call()en .bind(). ​ Een geneste functie is een functie die binnen een andere is gedefinieerd. Dit wordt gemaakt elke keer dat de buitenste functie wordt aangeroepen. Ook vormt elke gecreëerde functie een afsluiting ; is het resultaat van het evalueren van een bereik dat een of meer variabelen bevat die afhankelijk zijn van een ander buitenste bereik, inclusief constanten, lokale variabelen en argumenten van de aanroepende buitenste functie. Het resultaat van het evalueren van die sluiting maakt deel uit van de interne status van elk functieobject, zelfs nadat de buitenste functie zijn evaluatie heeft voltooid. ]

Prototypisch

prototypes

JavaScript gebruikt prototypes in plaats van klassen voor het gebruik van overerving . Het is mogelijk om veel van de functies van klassen in traditionele objectgeoriënteerde talen te emuleren door prototypes te maken in JavaScript. ]

Functioneert als objectconstructors

Functies gedragen zich ook als constructors. Prefix een functie-aanroep met het trefwoord newcreate een nieuwe instantie van een prototype, die de eigenschappen en methoden van de constructor erft (inclusief de eigenschappen van het prototype Object). ECMAScript 5 biedt de methode Object.create, waarmee expliciet een instantie kan worden gemaakt zonder dat deze automatisch hoeft te erven van het prototype van het object (in oudere omgevingen kan het prototype van het gemaakte object verschijnen als null). De prototypeeigenschap constructor bepaalt het object dat wordt gebruikt voor het interne prototype van nieuw gemaakte objecten. Nieuwe methoden kunnen worden toegevoegd door het prototype van het object dat als constructor wordt gebruikt, te wijzigen. Vooraf gedefinieerde constructors in JavaScript, zoals Arrayu Object, hebben ook prototypes die kunnen worden gewijzigd. Hoewel dit mogelijk is, wordt het als een slechte gewoonte beschouwd om het prototype te wijzigen, Objectaangezien de meeste objecten in Javascript de methoden en eigenschappen van het object erven prototype, objecten die kunnen verwachten dat ze niet zijn gewijzigd. ]

Andere functies

Runtime-omgeving

JavaScript is meestal afhankelijk van de omgeving waarin het wordt uitgevoerd (bijvoorbeeld in een webbrowser ) om objecten en methoden te bieden waarmee scripts kunnen communiceren met de "buitenwereld". In feite is het afhankelijk van de omgeving om de mogelijkheid te bieden om scripts op te nemen of te importeren (bijvoorbeeld in HTML via de tag <script>). (Dit is geen taalfunctie, maar is gebruikelijk in de meeste JavaScript-implementaties.)

variadische functies

Aan de functie kan een onbepaald aantal parameters worden doorgegeven. De functie heeft er toegang toe via de parameters of ook via het lokale object arguments. Variadische functies kunnen ook worden gemaakt met behulp van de .apply().

Functioneert als methoden

In tegenstelling tot veel objectgeoriënteerde talen, is er geen onderscheid tussen functiedefinitie en methodedefinitie . In plaats daarvan vindt het onderscheid plaats tijdens de functieaanroep; een functie kan worden aangeroepen als een methode. Wanneer een functie wordt aangeroepen als een methode van een object, vertegenwoordigt het sleutelwoord this, dat een variabele is die lokaal is voor de functie, het object dat de functie heeft aangeroepen.

Arrays en de letterlijke definitie van objecten

Zoals veel scripttalen kunnen arrays en objecten ( associatieve arrays in andere talen) worden gemaakt met een verkorte syntaxis. In feite vormen deze letterlijke termen de basis van het JSON -gegevensformaat .

Normale uitdrukkingen

JavaScript ondersteunt ook reguliere expressies op een vergelijkbare manier als Perl , die een beknopte en krachtige syntaxis biedt voor tekstmanipulatie die geavanceerder is dan functies die zijn ingebouwd in stringobjecten. ]

Fabrikant-specifieke extensies

JavaScript valt officieel onder de Mozilla Foundation -organisatie en er worden regelmatig nieuwe taalfuncties toegevoegd. Slechts enkele JavaScript-engines ondersteunen deze functies echter:

• De eigenschappen geten set(ook ondersteund door WebKit, Opera, ​ ActionScript en Rhino). ]
• Voorwaardelijke clausules catch.
• Iterator-protocol overgenomen van Python .
• Coroutines ook overgenomen van Python.
• Genereren van lijsten en uitdrukkingen door begrip, ook overgenomen van Python.
• Stel het bereik in om te blokkeren via het trefwoord let.
• Destructurering van arrays en objecten (beperkte vorm van patroonherkenning).
• Concrete uitdrukkingen in functies (functie(args) expr).
• ECMAScript voor XML (E4X), een extensie die native XML-ondersteuning toevoegt aan ECMAScript.

Syntaxis en semantiek

de nieuwste versie van de taal is ECMAScript 2016 gepubliceerd op 17 juni 2016. ]

Simpele voorbeelden

Variabelen in JavaScript worden gedefinieerd met het trefwoord var : ]

var  x ;  // definieert de variabele x, hoewel er standaard geen waarde aan is toegewezen 
var  y  =  2 ;  // definieer de variabele y en wijs er de waarde 2 aan toe

Beschouw de opmerkingen in het bovenstaande voorbeeld, die worden voorafgegaan door 2 schuine strepen.

De taal bevat geen I/O- functies; de runtime-omgeving biedt het al. De ECMAScript-specificatie in de 5.1-editie vermeldt: ]

...inderdaad, er zijn geen bepalingen in deze specificatie voor externe gegevensinvoer of -uitvoer voor berekende resultaten.

De meeste runtime-omgevingen hebben echter een aangeroepen object console​ dat kan worden gebruikt om af te drukken door de uitvoerstroom van de foutopsporingsconsole. Hier is een eenvoudig programma dat "Hallo wereld!" afdrukt:

console . log ( "Hallo wereld!" );

Een recursieve functie :

functie  faculteit ( n )  { 
    if  ( n  ===  0 )  { 
        return  1 ; 
    } 
    retourneer  n  *  faculteit ( n  -  1 ); 
}

Voorbeelden van anonieme functie (of lambda- functie ) en een sluiting:

var  displayClosure  =  function ()  { 
    var  count  =  0 ; 
    return  functie  ()  { 
        return  ++ count ; 
    }; 
} 
var  inc  =  displayClosure (); 
inclusief ();  // retourneert 1 
inc ();  // retourneert 2 
inc ();  // retour 3

Zelfoproepende expressies stellen functies in staat om variabelen door te geven per parameter binnen hun eigen sluitingen.

var  v ; 
v  =  1 ; 
var  getValue  =  ( functie ( v )  { 
  retourfunctie  () { return v ; }; }( v ));  


v  =  2 ;

getValue ();  // 1

Meer geavanceerde voorbeelden

De volgende code toont verschillende functies van JavaScript.

/* Vind het kleinste gemene veelvoud (LCM) van twee getallen */ 
function  LCMCalculator ( x ,  y )  {  // constructorfunctie 
    var  checkInt  =  function  ( x )  {  // inner function 
        if  ( x  %  1  !==  0 )  { 
            gooi  nieuwe  TypeError ( x  +  " is geen geheel getal" );  // gooi een uitzondering 
        } 
        return  x ; 
    }; 
    dit . a  =  checkInt ( x )  // puntkomma 's zijn optioneel 
    dit . b  =  checkInt ( en ); 
} 
// Het prototype van de objectinstanties die door de constructor zijn gemaakt, is dat van de eigenschap "prototype" van de constructor. 
LCM-calculator . prototype  =  {  // object gedefinieerd als letterlijke 
    constructor :  LCMCalculator ,  // wanneer we een prototype opnieuw toewijzen, stellen we de constructoreigenschap 
    ggd :  function  () correct in  {  // methode die de grootste gemene deler berekent 
        // Euclid's algoritme: 
        var  a  =  Wiskunde . abs ( dit . a ),  b  =  Math . buikspieren ( dit .b ) , t ; if ( a < b ) { // swap variabelen t = b ; b = een ; een = t ; } while ( b !== 0 ) { t = b ; b = a % b ; een = t ; } // We hoeven de GCF maar één keer te berekenen, dus we 'herdefiniëren' deze methode. // (Niet echt een override—het is gedefinieerd op de instantie zelf, dus // this.gcd verwijst naar deze 'override' in plaats van naar LCMCalculator.prototype.gcd). // Ook 'gcd' === "gcd", this['gcd'] === this.gcd this [ 'gcd' ] = function () { return a ; }; terug naar ; }, // Namen van objecteigenschappen kunnen worden opgegeven met tekenreeksen die worden gescheiden door enkele aanhalingstekens (') of dubbele aanhalingstekens (“). "lcm" : function () { // Variabelenamen komen niet in botsing met objecteigenschappen. Bijvoorbeeld: |lcm| is niet |this.lcm|. // Gebruik |this.a * this.b| . niet om problemen met drijvende-kommaberekeningen te voorkomen. var lcm = dit . naar / dit . ggd () * dit . b ; // We hoeven LCM maar één keer te berekenen, dus we "herdefiniëren" deze methode. dit . lcm = functie () { retour lcm ; }; retour lcm ; }, toString : function () { return "LCMCalculator: a = " + this . a + ", b = " + dit . b ; } }; 
            
            
              
              
              
        
            
              
                
              
        
        
        
        
        
            
             
        
         
    
    
        
        
        
               
        
            
             
        
         
    
       
               
    


// We definiëren een generieke functie om een ​​resultaat af te drukken; deze implementatie werkt alleen in webbrowsers 
function  output ( x )  { 
    document . lichaam . appendChild ( document . createTextNode ( x )); 
    documenteren . lichaam . appendChild ( document . createElement ( 'br' )); 
}

// Opmerking: de methoden .map() en .forEach() van het Array-prototype zijn gedefinieerd in JavaScript 1.6. 
// Deze methoden worden hier gebruikt om de inherente functionele aard van de taal aan te tonen. 
[[ 25 ,  55 ],  [ 21 ,  56 ],  [ 22 ,  58 ],  [ 28 ,  56 ]]. map ( functie  ( paar )  {  // letterlijke constructie van een Array + mapping-functie. 
    retourneer  nieuwe  LCMCalculator ( paar [ 0 ],  paar [ 1 ]); 
}). sort ( function  ( a ,  b )  {  // sorteer de collectie met deze functie 
    return  a . lcm ()  -  b . lcm (); 
}). forEach ( functie  ( obj )  { 
    output ( obj  +  ", ggd = "  +  obj . ggd ()  +  ", lcm = "  +  obj . lcm ()); 
});

Het volgende voorbeeld toont de uitvoer die in een browservenster moet worden weergegeven.

LCMCalculator: a = 28, b = 56, ggd = 28, lcm = 56
LCMCalculator: a = 21, b = 56, ggd = 7, lcm = 168
LCMCalculator: a = 25, b = 55, ggd = 5, lcm = 275
LCMCalculator: a = 22, b = 58, ggd = 2, lcm = 638

Gebruik op webpagina's

Zie ook: JavaScript en AJAX- interpreter .

Het meest voorkomende gebruik van JavaScript is het schrijven van functies die zijn ingesloten in HTML-pagina's en die interageren met het Document Object Model (DOM) van de pagina. Enkele eenvoudige voorbeelden van dit gebruik zijn:

• Upload nieuwe inhoud voor de pagina of stuur gegevens naar de server via AJAX zonder de pagina opnieuw te laden (een sociaal netwerk kan de gebruiker bijvoorbeeld toestaan ​​om statusupdates te verzenden zonder de pagina te verlaten).
• Animeer pagina-elementen, laat ze verdwijnen, formaat wijzigen, verplaatsen, enz.
• Interactieve inhoud, bijvoorbeeld games en het afspelen van audio en video.
• Validatie van de invoerwaarden van een webformulier om ervoor te zorgen dat ze acceptabel zijn voordat ze naar de server worden verzonden.
• Overdracht van informatie over het leesgedrag en de browse-activiteiten van gebruikers naar verschillende websites. Webpagina's doen dit vaak voor webanalyse, het volgen van advertenties, personalisatie of andere doeleinden. ]

Omdat JavaScript-code lokaal in de browser van de gebruiker kan worden uitgevoerd (in plaats van op een externe server), kan de browser snel reageren op gebruikersacties, waardoor een toepassing sneller reageert. Aan de andere kant kan JavaScript-code gebruikersacties detecteren die HTML alleen niet kan, zoals toetsaanslagen. Toepassingen zoals Gmail profiteren hiervan: de meeste logica van de gebruikersinterface is geschreven in JavaScript en stuurt verzoeken naar de server (bijvoorbeeld de inhoud van een e-mailbericht). De groeiende trend voor het gebruik van Ajax-programmering maakt op dezelfde manier gebruik van deze techniek.

Een JavaScript-engine (ook bekend als een JavaScript-interpreter of JavaScript-implementatie) is een interpreter die de JavaScript-broncode interpreteert en het script dienovereenkomstig uitvoert. De eerste JavaScript-engine is gemaakt door Brendan Eich van Netscape Communications Corporation, voor de Netscape Navigator-webbrowser. De engine, genaamd SpiderMonkey, is geïmplementeerd in C. Het is sindsdien bijgewerkt (in JavaScript 1.5) om te voldoen aan ECMA-262 editie 3. De Rhino-engine, voornamelijk gemaakt door Norris Boyd (voorheen van Netscape, nu bij Google) is een implementatie van JavaScript in Java . Rhino is, net als SpiderMonkey, compatibel met ECMA-262 editie 3.

Een webbrowser is verreweg de meest gebruikte hostingomgeving voor JavaScript. Webbrowsers maken vaak niet-eigen, runtime-afhankelijke objecten om het Document Object Model (DOM) in JavaScript weer te geven. De webserver is een andere veel voorkomende serviceomgeving. Een JavaScript-webserver stelt doorgaans zijn eigen objecten bloot om HTTP-verzoek- en responsobjecten weer te geven, die een JavaScript-programma vervolgens zou kunnen ondervragen en manipuleren om dynamisch webpagina's te genereren.

Omdat JavaScript de enige taal is waarvoor de meeste populaire browsers ondersteuning delen, is het een taal geworden waar veel frameworks in andere talen naar compileren, ook al is JavaScript niet voor dergelijke doeleinden ontworpen. Ondanks de prestatiebeperkingen die inherent zijn aan zijn dynamische karakter, heeft de verhoogde snelheid van JavaScript-engines deze taal tot een verrassend haalbare compilatie-omgeving gemaakt.

Script voorbeeld

Hier is een kort voorbeeld van een webpagina (conform de standaarden van de HTML5 -standaard ) die JavaScript gebruikt voor DOM -verwerking :

<!DOCTYPE html> 
< html > 
< head > 
    < meta  charset = "utf-8" > 
    < title > Eenvoudig voorbeeld </ title > 
</ head > 
< body > 
    < h1  id = "header" > Dit is JavaScript </ h1 >

    < script > 
        document . lichaam . appendChild ( document . createTextNode ( 'Hallo wereld!' ));
    
        var  h1  =  document . getElementById ( 'kop' );  // bevat de verwijzing naar de <h1> tag 
        h1  =  document . getElementsByTagName ( 'h1' ) [ 0 ];  // toegang krijgen tot hetzelfde <h1> element 
    </ script >

    < noscript > Uw browser ondersteunt geen JavaScript, of JavaScript is uitgeschakeld. </ noscript > 
</ body > 
</ html >

Compatibiliteitsoverwegingen

Omdat JavaScript in zoveel verschillende omgevingen draait, is een belangrijk onderdeel van testen en debuggen het testen en verifiëren dat uw JavaScript-code correct werkt in meerdere browsers. De DOM-interface voor het openen en manipuleren van webpagina's maakt geen deel uit van de ECMAScript-standaard of JavaScript zelf. De DOM wordt bepaald door de standaardisatie-inspanningen van de W3C , een onafhankelijke organisatie. In de praktijk verschillen JavaScript-implementaties door verschillende browsers zowel van elkaar als van de standaarden.

Om deze verschillen aan te pakken, waren JavaScript-auteurs in staat om standaardcode te schrijven die ook correct zou werken in de meeste browsers, of als dat niet lukt, in ieder geval code te schrijven die de aanwezigheid van bepaalde browserfunctionaliteiten kan controleren en die zich anders gedraagt ​​als gezegd functionaliteit is niet beschikbaar. Er zijn gevallen waarin twee browsers dezelfde functie kunnen implementeren, maar met verschillend gedrag, een feit dat programmeurs kan helpen om te detecteren welke browser op dat moment actief is en zo het gedrag van uw schrijven aan te passen. ​ Ook programmeurs gebruiken vaak bibliotheken of tools die rekening houden met de verschillen tussen browsers.

Ook werken de scripts mogelijk niet voor sommige gebruikers. Een gebruiker kan bijvoorbeeld:

• Een oudere browser gebruiken zonder volledige DOM API-ondersteuning,
• Gebruik een PDA of mobiele telefoon browser die geen JavaScript kan uitvoeren
• JavaScript-uitvoering uitschakelen als veiligheidsmaatregel,
• Het gebruik van een spraakbrowser vanwege bijvoorbeeld een visuele beperking.

Om deze gebruikers te ondersteunen, maken webontwikkelaars vaak pagina's die fouttolerant zijn op basis van user-agent (browsertype) die geen JavaScript ondersteunt. In het bijzonder zou de pagina nog steeds nuttig moeten zijn zonder de extra functies die JavaScript zou hebben toegevoegd. Een alternatieve benadering waar velen de voorkeur aan geven, is om eerst inhoud te maken met behulp van technologieën die in alle browsers werken, en de inhoud te verbeteren voor gebruikers die JavaScript hebben ingeschakeld.

Toegankelijkheid

Ervan uitgaande dat de gebruiker de uitvoering van JavaScript-code niet heeft uitgeschakeld, moet JavaScript aan de clientzijde worden geschreven om de ervaringen van bezoekers met visuele of fysieke beperkingen te verbeteren en om te voorkomen dat informatie voor deze bezoekers wordt verborgen. ]

Schermlezers , gebruikt door blinden en slechtzienden, kunnen door JavaScript in aanmerking worden genomen en kunnen zo de DOM-elementen van de pagina openen en lezen . Geschreven HTML-code moet zo beknopt, navigeerbaar en semantisch mogelijk zijn, of JavaScript nu wordt uitgevoerd of niet.

JavaScript mag niet volledig afhankelijk zijn van muisgebeurtenissen in de browser en moet toegankelijk zijn voor gebruikers die de muis (computer) niet willen gebruiken om te navigeren of die ervoor kiezen om alleen het toetsenbord te gebruiken. Er zijn apparaatonafhankelijke gebeurtenissen zoals onfocusen onchangedie in de meeste gevallen de voorkeur hebben. ]

JavaScript mag niet worden gebruikt om verwarring of desoriëntatie bij de internetgebruiker te veroorzaken. Het wijzigen of uitschakelen van de normale browserfunctionaliteit, zoals het wijzigen van de manier waarop de knop voor teruggaan of vernieuwen zich gedraagt, zijn bijvoorbeeld praktijken die over het algemeen het best kunnen worden vermeden. Evenzo vermindert het activeren van gebeurtenissen waarvan de gebruiker zich misschien niet bewust is, het gevoel van controle van de gebruiker en veroorzaakt onverwachte wijzigingen in de pagina-inhoud. ]

Vaak wordt het proces van het aanbieden van een complexe webpagina met de hoogst mogelijke toegankelijkheid een niet-triviaal probleem waarbij veel kwesties uiteindelijk worden besproken en een mening wordt gegeven, waarbij ieders inzet tot het einde nodig is. User agents en ondersteunende technologieën voor mensen met een handicap zijn echter voortdurend in ontwikkeling en er worden nog steeds nieuwe richtlijnen en informatie op internet geplaatst. ]

Beveiliging

Zie ook: Browserbeveiliging

JavaScript en de DOM stellen programmeurs in staat het te misbruiken om scripts te introduceren die code uitvoeren met kwaadaardige inhoud zonder toestemming van de gebruiker, waardoor de veiligheid van de gebruiker in gevaar komt.

Browserontwikkelaars houden rekening met dit risico door twee beperkingen te hanteren. Ten eerste worden de scripts uitgevoerd in een sandbox waar alleen webgerelateerde acties kunnen worden uitgevoerd, geen algemene programmeertaken zoals het maken van bestanden. Ten tweede wordt het beperkt door hetzelfde oorsprongsbeleid: scripts van de ene website hebben geen toegang tot informatie die naar een andere website (vanaf een ander domein) wordt verzonden, zoals gebruikersnamen, wachtwoorden of cookies. De meeste JavaScript-beveiligingsfouten houden verband met schendingen van een van deze twee beperkingen.

Er zijn projecten zoals AdSafe of Secure ECMA script (SES) die hogere beveiligingsniveaus bieden, vooral in code die door derden is gemaakt (zoals advertenties). ]

Het Content Secure Policy (CSP) is de primaire methode die wordt overwogen om ervoor te zorgen dat alleen vertrouwde code op een webpagina kan worden uitgevoerd.

Cross

Een veelvoorkomend beveiligingsprobleem in JavaScript is cross-site scripting of XSS, een schending van het beleid van dezelfde oorsprong. XSS-kwetsbaarheden stellen een aanvaller in staat JavaScript-code te injecteren in webpagina's die door de gebruiker worden bezocht. Een dergelijke website zou die van een bank kunnen zijn, waarbij de aanvaller toegang heeft tot de bankapplicatie met de privileges van het slachtoffer, die geheime informatie kan onthullen of geld kan overmaken zonder toestemming van het slachtoffer. Een oplossing voor XSS-kwetsbaarheden is het gebruik van HTML-escaping bij het weergeven van informatie uit niet-vertrouwde bronnen.

Sommige browsers bieden gedeeltelijke bescherming tegen gereflecteerde XSS-aanvallen (de aanvaller bevindt zich in hetzelfde webverzoek). De aanvaller levert een URL met kwaadaardige code. Maar zelfs browsergebruikers zijn kwetsbaar voor andere XSS-aanvallen, zoals aanvallen waarbij kwaadaardige code wordt opgeslagen in een database. Alleen het juiste ontwerp van webapplicaties aan de serverkant kan XSS volledig voorkomen. XSS-kwetsbaarheden kunnen ook optreden als gevolg van uitvoeringsfouten door browserontwikkelaars. ]

Een andere kwetsbaarheid is cross-site request forgery of CSRF. In CSRF bedriegt de code van de aanvallende website de browser van het slachtoffer, waardoor de aanvaller namens het slachtoffer verzoeken kan doen, waardoor het voor de doeltoepassing (bijvoorbeeld een bank die een geldoverboeking doet) onmogelijk wordt om te weten of het verzoek vrijwillig is gedaan door de gebruiker of door een CSRF-aanval.

De aanval werkt omdat, als de doelsite alleen cookies gebruikt om verzoeken van slachtoffers te verifiëren, verzoeken die door de code van de aanvaller worden gestart, dezelfde legitieme toegangsgegevens zullen hebben als door de gebruiker geïnitieerde verzoeken.

Over het algemeen is de oplossing voor CSRF om een ​​verborgen formulierveld in te voeren waarvan de waarde wordt gebruikt om authenticatie uit te voeren, en niet alleen via cookies, op verzoeken die blijvende gevolgen kunnen hebben. Het controleren van de HTTP-refererheader kan ook helpen.

"JavaScript-kaping" is een type CSRF-aanval waarbij een <script>-tag op de website van de aanvaller misbruik maakt van een kwetsbaarheid op de pagina van de site van het slachtoffer waardoor privé-informatie wordt geretourneerd in de vorm van JSON- of JavaScript-code. Mogelijke oplossingen zijn:

• dat een authenticatietoken vereist is in de parameters van de POST- en GET-verzoeken voor die verzoeken waarvoor privégebruikersinformatie moet worden geretourneerd.
• gebruik POST en nooit GET voor verzoeken die privé-informatie retourneren

Ontwikkeltools

In JavaScript wordt het hebben van een debugger noodzakelijk bij het ontwikkelen van grote, niet-triviale applicaties. Aangezien er implementatieverschillen kunnen zijn tussen verschillende browsers (vooral in termen van de DOM), is het handig om toegang te hebben tot een debugger voor elk van de browsers waarop onze webtoepassing zich zal richten. ]

Webdebuggers zijn beschikbaar voor Internet Explorer, Firefox, Safari, Google Chrome en Opera. ]

Er zijn drie debuggers beschikbaar voor Internet Explorer : Microsoft Visual Studio is de meest geavanceerde van de drie, op de voet gevolgd door Microsoft Script Editor (een onderdeel van Microsoft Office ) en tenslotte Microsoft Script Debugger, dat veel eenvoudiger is dan de andere twee, hoewel het gratis is. De gratis Microsoft Visual Web Developer Express IDE biedt een beperkte versie van de JavaScript-foutopsporingsfunctionaliteit in Microsoft Visual Studio. Internet Explorer bevat sinds versie 8 ontwikkelaarstools (weergegeven door op de F12-toets te drukken). Webapplicaties binnen Firefox kunnen worden gedebugd met behulp van de Firebug -add-on of de oude Venkman-debugger. Firefox heeft ook een ingebouwde basisfoutconsole, die JavaScript registreert en evalueert. Het registreert ook CSS- fouten en waarschuwingen. Opera bevat een set tools genaamd Dragonfly. WebKit 's Web Inspector bevat een JavaScript-foutopsporing die in Safari wordt gebruikt , samen met een aangepaste versie van Google Chrome .

Er zijn enkele hulptools voor foutopsporing, ook geschreven in JavaScript en gebouwd om op het web te draaien. Een voorbeeld is het JSLint -programma , ontwikkeld door Douglas Crockford , die uitgebreid over de taal heeft geschreven. JSLint ontleedt JavaScript-code zodat deze voldoet aan een reeks standaarden en richtlijnen om de juiste functionaliteit en onderhoudbaarheid te garanderen.

Zie ook

• VBScript
• AJAX
• Web applicatie
• Documentobjectmodel
• jQuery
• JSON
• HTML
• HTML5

Externe links

• Mozilla-ontwikkelaarscentrum .
• (in het Engels) Javascript-tutorial .
• JavaScript - Een kijkje achter de schermen .