Javascript

javascript
?
Allmän information
Vanliga tillägg	.js
Paradigm	Multiparadigm , funktionell programmering , ​prototypbaserad programmering , imperativ , tolkad ( scripting )
Framträdde i	4 december 1995
Designad av	Netscape Communications , Mozilla Foundation
Senaste stabila versionen	ECMAScript 2021 (1 juni 2021 (1 år, 4 månader och 15 dagar))
typsystem	svag, dynamisk, anka
implementeringar	SpiderMonkey , Rhino , KJS , JavaScriptCore , V8 , Chakra .
dialekter	ECMAScript
påverkad av	Java , Perl , Self , Python , C , Scheme
har påverkat	ObjectiveJ, JScript .NET, TIScript

JavaScript (vanligtvis förkortat JS ) är ett tolkat programmeringsspråk , dialekt av ECMAScript- standarden . Den definieras som objektorienterad , prototypbaserad , imperativ, svagt typad och dynamisk .

Den används främst på klientsidan , implementerad som en del av en webbläsare som tillåter förbättringar av användargränssnittet och dynamiska webbsidor och JavaScript på serversidan ( Server-side JavaScript eller SSJS ). Dess användning i applikationer utanför webben , till exempel i PDF -dokument , skrivbordsapplikationer (mest widgets ) är också betydande.

Sedan 2012 har alla moderna webbläsare fullt stöd för ECMAScript 5.1, en version av JavaScript. Äldre webbläsare stöder minst ECMAScript 3. Den sjätte utgåvan släpptes i juli 2015. ]

JavaScript designades med syntax som liknar C++ och Java , ​ även om det antar namn och konventioner från programmeringsspråket Java. Java och JavaScript har dock olika semantik och syften. Deras förhållande är rent kommersiellt, efter köpet av skaparen av Java (Sun Microsystems) från Nestcape Navigator (skaparen av LiveScript) och namnbytet på programmeringsspråket.

Alla moderna webbläsare tolkar JavaScript-kod inbäddad i webbsidor. För att interagera med en webbsida är JavaScript-språket försett med en implementering av Document Object Model (DOM). Javascript är det enda programmeringsspråket som webbläsare förstår.

Traditionellt har det använts i HTML -webbsidor för att utföra operationer och endast inom ramen för klientapplikationen , utan tillgång till serverfunktioner . Det används för närvarande flitigt för att skicka och ta emot information från servern tillsammans med hjälp av andra teknologier som AJAX . JavaScript tolkas av användaragenten eftersom uttalandena laddas ner tillsammans med HTML -koden .

Sedan lanseringen av ECMAScript 1-standarden i juni 1997 har det funnits versionerna 2, 3 och 5, som är den mest använda idag (version 4 lades ner ). I juni 2015 stängdes och publicerades ECMAScript 6-versionen. ]

Historik

JavaScripts födelse

JavaScript utvecklades ursprungligen av Brendan Eich från Netscape under namnet Mocha , som senare döptes om till LiveScript , och så småningom blev JavaScript. Namnbytet sammanföll ungefär med den tid då Netscape lade till Java-teknikstöd till sin Netscape Navigator webbläsare i version 2002 i december 1995. Namnet orsakade förvirring, vilket gav intrycket att språket är en förlängning av Java. , och ansågs av många. som en marknadsföringsstrategi för Netscape för att vinna prestige och förnya sig inom området nya webbprogrammeringsspråk. ]

"JAVASCRIPT" är ett registrerat varumärke som tillhör Oracle Corporation . Det används under licens av produkter skapade av Netscape Communications och nuvarande enheter som Mozilla Foundation . ]

Microsoft döpte sin dialekt av JavaScript till " JScript ", för att undvika varumärkesproblem. JScript antogs i version 3.0 av Internet Explorer, som släpptes i augusti 1996, och inkluderade Effect 2000- stöd för datumfunktioner, en avvikelse från de som baserades på den tiden. Dialekterna kan verka så lika att termerna "JavaScript" och "JScript" ofta används omväxlande, men JScript-specifikationen är på många sätt inkompatibel med ECMA-specifikationen.

För att undvika dessa inkompatibiliteter utformade World Wide Web Consortium standarden Document Object Model (DOM, eller Document Object Model på spanska) som innehåller Konqueror , version 6 av Internet Explorer och Netscape Navigator , Opera version 7, Mozilla Application Suite och Mozilla Firefox från sin första version. ^{[ citat behövs ]}

1997 föreslog författarna att JavaScript skulle antas som en standard av European Computer Manufacturers' Association ECMA , som trots sitt namn inte är europeisk utan internationell, med säte i Genève. I juni 1997 antogs den som en ECMA-standard, under namnet ECMAScript . Strax efter även som ISO- standard .

JavaScript på serversidan

Netscape introducerade en skriptimplementering på serversidan med Netscape Enterprise Server , som släpptes i december 1994 (kort efter lanseringen av JavaScript för webbläsare). ​ Med början i mitten av 2000-talet har det skett en spridning av JavaScript-implementeringar på serversidan. Node.js är ett av de anmärkningsvärda exemplen på JavaScript på serversidan som används i stora projekt. ]

Senare utvecklingar

JavaScript har blivit ett av de mest populära och mest använda programmeringsspråken på internet. Till en början var det dock många utvecklare som ogillade språket eftersom dess avsedda målgrupp bland annat bestod av artikelförlag och andra hobbyister. Ankomsten av Ajax förde JavaScript tillbaka till framträdande plats och lockade många andra programmerares uppmärksamhet. Som ett resultat av detta skedde en spridning av en uppsättning ramverk och bibliotek av allmän räckvidd, förbättrade JavaScript-programmeringsmetoder och ökad användning av JavaScript utanför webbläsare , vilket kan ses med spridningen av JavaScript-miljöer på webbsidan. server . I januari 2009 lanserades CommonJS- projektet med målet att specificera ett bibliotek för användning av vanliga uppgifter i första hand för utveckling utanför webbläsaren. ]

I juni 2015 stängdes ECMAScript 6 -standarden och publicerades ​ med oregelbundet stöd mellan webbläsare ​ och som förser JavaScript med avancerade funktioner som missades och som ofta används i JavaScript. andra språk, t.ex. som moduler för kodorganisation, sanna klasser för objektorienterad programmering , piluttryck, iteratorer, generatorer eller löften för asynkron programmering.

Version 7 av ECMAScript är känd som ECMAScript 2016, och är den senaste versionen som släpptes i juni 2016. Det är den första versionen som använder en ny årlig utgivningsprocedur och utvecklingsprocess. ]

Funktioner

Följande funktioner är gemensamma för alla implementeringar som överensstämmer med ECMAScript-standarden, om du inte uttryckligen anger något annat.

Imperativ och strukturerad

JavaScript stöder mycket av programmeringsstrukturen för C (till exempel satser if, loopar for, satser switchetc.). Med en varning, delvis: i C är variabler omfångade till blocket där de definierades; JavaScript stöder dock inte detta, eftersom omfattningen av variabler är den för funktionen där de deklarerades. Detta ändras med ECMAScript 2015-versionen, eftersom den lägger till stöd för block scoping via nyckelordet . Som i C, gör JavaScript en skillnad mellan uttryck och påståenden. En syntaktisk skillnad med avseende på C är den automatiska infogningen av semikolon, det vill säga i JavaScript kan semikolon som avslutar en mening utelämnas. ] let

Dynamisk

dynamisk typning

Som i de flesta skriptspråk är typen kopplad till värdet, inte variabeln. Till exempel kan en variabel xvid ett tillfälle bindas till ett tal och senare återgå till en sträng . JavaScript stöder flera sätt att kontrollera typen av ett objekt, inklusive duck typing . Ett sätt att ta reda på det är genom nyckelordet typeof.

objektivt

JavaScript består nästan uteslutande av objekt . Objekt i JavaScript är associativa arrayer , förstärkta genom införandet av prototyper (se nedan). Objektegenskapsnamn är nycklar av typen string: obj.x = 10och obj['x'] = 10är likvärdiga, punktnotationen är syntaktisk sugar . Egenskaper och deras värden kan skapas, ändras eller tas bort under körning. De flesta egenskaper för ett objekt (och de som ingår i den prototypiska arvskedjan) kan räknas upp via loop-satsen for... in. JavaScript har ett litet antal fördefinierade objekt som Functionoch Date.

Körtidsutvärdering

JavaScript inkluderar möjligheten evalatt utvärdera uttryck uttryckta som strängar vid körning. Av denna anledning rekommenderas att evalden används med försiktighet och att du väljer att använda funktionen JSON.parse()så mycket som möjligt, eftersom det kan vara mycket säkrare.

Funktionell

Förstklassiga funktioner

Funktioner kallas ofta förstklassiga medborgare; de är objekt i sig själva. Som sådana har de egenskaper och metoder, som .call()och .bind(). ​ En kapslad funktion är en funktion som definieras inuti en annan. Detta skapas varje gång den yttre funktionen anropas. Dessutom bildar varje skapad funktion en stängning ; är resultatet av att utvärdera ett omfång som innehåller en eller flera variabler som är beroende av ett annat yttre omfång, inklusive konstanter, lokala variabler och argument för den anropande yttre funktionen. Resultatet av att utvärdera den stängningen är en del av det interna tillståndet för varje funktionsobjekt, även efter att den yttre funktionen har slutfört sin utvärdering. ]

Prototypisk

prototyper

JavaScript använder prototyper istället för klasser för användning av arv . Det är möjligt att emulera många av funktionerna som klasser tillhandahåller i traditionella objektorienterade språk genom att skapa prototyper i JavaScript. ]

Fungerar som objektkonstruktörer

Funktioner beter sig också som konstruktörer. Prefix ett funktionsanrop med nyckelordet newskapa en ny instans av en prototyp, som ärver konstruktorns egenskaper och metoder (inklusive prototypens egenskaper Object). ECMAScript 5 tillhandahåller metoden som Object.createtillåter explicit skapande av en instans utan att automatiskt behöva ärva från objektprototypen (i äldre miljöer kan det skapade objektets prototyp visas som null). Konstruktoregenskapen prototypebestämmer objektet som används för den interna prototypen av nyskapade objekt. Nya metoder kan läggas till genom att modifiera prototypen för objektet som används som konstruktor. Fördefinierade konstruktörer i JavaScript, som Arrayu Object, har också prototyper som kan modifieras. Även om detta är möjligt anses det vara dålig praxis att modifiera prototypen av Objecteftersom de flesta objekt i Javascript ärver objektets metoder och egenskaper prototype, objekt som kan förvänta sig att de inte har modifierats. ]

Andra funktioner

Runtime miljö

JavaScript beror vanligtvis på miljön i vilken det körs (till exempel i en webbläsare ) för att tillhandahålla objekt och metoder genom vilka skript kan interagera med "omvärlden". Faktum är att det beror på miljön för att kunna tillhandahålla möjligheten att inkludera eller importera skript (till exempel i HTML via taggen <script>). (Detta är inte en språkfunktion, men är gemensam för de flesta JavaScript-implementeringar.)

variatiska funktioner

Ett obestämt antal parametrar kan skickas till funktionen. Funktionen kan komma åt dem via parametrarna eller även genom det lokala objektet arguments. Variadiska funktioner kan också skapas med hjälp av .apply().

Fungerar som metoder

Till skillnad från många objektorienterade språk finns det ingen skillnad mellan funktionsdefinition och metoddefinition . Snarare sker distinktionen under funktionsanropet; en funktion kan kallas som en metod. När en funktion anropas som en metod för ett objekt, thisrepresenterar nyckelordet , som är en variabel lokal för funktionen, det objekt som anropade funktionen.

Arrayer och den bokstavliga definitionen av objekt

Liksom många skriptspråk kan arrayer och objekt ( associativa arrayer på andra språk) skapas med en stenografisyntax. Faktum är att dessa bokstaver utgör grunden för JSON -dataformatet .

Vanliga uttryck

JavaScript stöder även reguljära uttryck på ett liknande sätt som Perl , som ger en kortfattad och kraftfull syntax för textmanipulering som är mer sofistikerad än funktioner inbyggda i strängobjekt. ]

Tillverkarspecifika tillägg

JavaScript är officiellt under Mozilla Foundation- organisationen och nya språkfunktioner läggs till med jämna mellanrum. Men bara vissa JavaScript-motorer stöder dessa funktioner:

• Egenskaperna getoch set(stöds även av WebKit, Opera, ​ ActionScript och Rhino). ]
• Villkorliga klausuler catch.
• Iteratorprotokoll antagits från Python .
• Coroutines har också antagits från Python.
• Generering av listor och uttryck genom förståelse också antagen från Python.
• Ställ in omfattningen för att blockera via nyckelordet let.
• Destrukturering av arrayer och objekt (begränsad form av mönstermatchning).
• Konkreta uttryck i funktioner (function(args) expr).
• ECMAScript for XML (E4X), ett tillägg som lägger till inbyggt XML-stöd till ECMAScript.

Syntax och semantik

den senaste versionen av språket är ECMAScript 2016 publicerad den 17 juni 2016. ]

Enkla exempel

Variabler i JavaScript definieras med nyckelordet var : ]

var  x ;  // definierar variabeln x, även om den inte har något värde tilldelat som standard 
var  y  =  2 ;  // definiera variabeln y och tilldela värdet 2 till den

Tänk på kommentarerna i exemplet ovan, som föregås av 2 snedstreck framåt.

Det finns inga I/O- funktioner i språket; runtime-miljön tillhandahåller det redan. ECMAScript-specifikationen i sin 5.1-utgåva nämner: ]

...det finns faktiskt inga bestämmelser i denna specifikation för extern datainmatning eller -utmatning för beräknade resultat.

De flesta runtime-miljöer har dock ett objekt ​ som kallas consolesom kan användas för att skriva ut av felsökningskonsolens utdataström. Här är ett enkelt program som skriver ut "Hello world!":

konsol . log ( "Hej världen!" );

En rekursiv funktion :

function  factorial ( n )  { 
    if  ( n  ===  0 )  { 
        return  1 ; 
    } 
    returnera  n  *  faktoriell ( n  -  1 ); 
}

Exempel på anonym funktion (eller lambdafunktion ) och en stängning:

var  displayClosure  =  function ()  { 
    var  count  =  0 ; 
    return  function  ()  { 
        return  ++ count ; 
    }; 
} 
var  inc  =  displayClosure (); 
inc ();  // returnerar 1 
inc ();  // returnerar 2 
inc ();  // retur 3

Självanropande uttryck tillåter funktioner att skicka variabler till det genom parameter inom sina egna stängningar.

var  v ; 
v  =  1 ; 
var  getValue  =  ( function ( v )  { 
  return  function ()  { return  v ;}; 
}( v ));

v  =  2 ;

getValue ();  // 1

Mer avancerade exempel

Följande kod visar olika funktioner i JavaScript.

/* Hitta minsta gemensamma multipel (LCM) av två tal */ 
function  LCMCalculator ( x ,  y )  {  // constructor function 
    var  checkInt  =  function  ( x )  {  // inre function 
        if  ( x  %  1  !==  0 )  { 
            kasta  nytt  TypeError ( x  +  " är inte ett heltal" );  // kasta ett undantag 
        } 
        returnera  x ; 
    }; 
    detta . a  =  checkInt ( x )  // semikolon är valfria 
    detta . b  =  checkInt ( och ); 
} 
// Prototypen för objektinstanserna som skapats av konstruktorn är den för konstruktorns "prototype"-egenskap. 
LCMC-kalkylator . prototyp  =  {  // objekt definierat som bokstavlig 
    konstruktor :  LCMCalculator ,  // när vi omtilldelar en prototyp ställer vi in ​​dess konstruktoregenskap 
    gcd :  function  ()  {  // metod som beräknar den största gemensamma faktorn 
        // Euklids algoritm: 
        var  a  =  Matematik . abs ( detta . a ),  b  =  Math . abs ( detta . b ),  t ; 
        if  ( a  <  b )  { 
            // swap variabler 
            t  =  b ; 
            b  =  a ; 
            a  =  t ; 
        } 
        while  ( b  !==  0 )  { 
            t  =  b ; 
            b  =  a  %  b ; 
            a  =  t ; 
        } 
        // Vi behöver bara beräkna GCF en gång, så vi "omdefinierar" denna metod. 
        // (Inte riktigt en åsidosättande – den är definierad på själva instansen, så 
        // this.gcd refererar till denna 'åsidosättning' snarare än LCMCalculator.prototype.gcd). 
        // Dessutom, 'gcd' === "gcd", this['gcd'] === this.gcd 
        this [ 'gcd' ]  =  function  ()  { 
            return  a ; 
        }; 
        återgå  till ; 
    }, 
    // Objektegenskapsnamn kan anges med strängar avgränsade med enkla citattecken (') eller dubbla citattecken (“). 
    "lcm"  :  function  ()  { 
        // Variabelnamn kolliderar inte med objektegenskaper. Till exempel: |lcm| är inte |this.lcm|. 
        // Använd inte |this.a * this.b| för att undvika problem med flyttalsberäkningar. 
        var  lcm  =  detta . till  /  detta . gcd ()  *  detta . b ; 
        // Vi behöver bara beräkna LCM en gång, så vi "omdefinierar" denna metod. 
        detta . lcm  =  funktion  ()  { 
            return  lcm ; 
        }; 
        returnera  lcm ; 
    }, 
    toString :  function  ()  { 
        return  "LCMCalculator: a = "  +  detta . a  +  ", b = "  +  detta . b ; 
    } 
};

// Vi definierar en generisk funktion för att skriva ut ett resultat; 
den här implementeringen fungerar bara i webbläsares funktionsutgång  ( x ) { document . kropp . appendChild ( dokument . createTextNode ( x )); dokument . kropp . appendChild ( dokument . createElement ( 'br' )); } 
    
    


// Obs: Metoderna .map() och .forEach() för Array-prototypen definieras i JavaScript 1.6. 
// Dessa metoder används här för att demonstrera språkets inneboende funktionella natur. 
[[ 25 ,  55 ],  [ 21 ,  56 ],  [ 22 ,  58 ],  [ 28 ,  56 ]]. map ( function  ( par )  {  // bokstavlig konstruktion av en Array + mappningsfunktion. 
    returnera  ny  LCMCalculator ( par [ 0 ],  par [ 1 ]); 
}). sort ( function  ( a ,  b )  {  // sortera samlingen med den här funktionen 
    returnera  a . lcm ()  -  b . lcm (); 
}). forEach ( function  ( obj )  { 
    output ( obj  +  ", gcd = "  +  obj . gcd ()  +  ", lcm = "  +  obj . lcm ()); 
});

Följande exempel visar utdata som ska visas i ett webbläsarfönster.

LCMC-kalkylator: a = 28, b = 56, gcd = 28, lcm = 56
LCMC-kalkylator: a = 21, b = 56, gcd = 7, lcm = 168
LCMC-kalkylator: a = 25, b = 55, gcd = 5, lcm = 275
LCMC-kalkylator: a = 22, b = 58, gcd = 2, lcm = 638

Användning på webbsidor

Se även: JavaScript och AJAX- tolk .

Den vanligaste användningen av JavaScript är att skriva funktioner som är inbäddade i HTML-sidor och som interagerar med sidans Document Object Model (DOM). Några enkla exempel på denna användning är:

• Ladda upp nytt innehåll för sidan eller skicka data till servern via AJAX utan att ladda om sidan (till exempel kan ett socialt nätverk tillåta användaren att skicka statusuppdateringar utan att lämna sidan).
• Animera sidelement, få dem att försvinna, ändra storlek, flytta osv.
• Interaktivt innehåll, till exempel spel och ljud- och videouppspelning.
• Validering av ingångsvärdena för ett webbformulär för att säkerställa att de är acceptabla innan de skickas till servern.
• Överföring av information om användarnas läsvanor och surfaktiviteter till olika webbplatser. Webbsidor gör ofta detta för webbanalys, annonsspårning, anpassning eller andra syften. ]

Eftersom JavaScript-kod kan köras lokalt i användarens webbläsare (snarare än på en fjärrserver), kan webbläsaren svara på användaråtgärder snabbt, vilket gör en applikation mer responsiv. Å andra sidan kan JavaScript-kod upptäcka användaråtgärder som HTML ensam inte kan, såsom tangenttryckningar. Applikationer som Gmail drar fördel av detta: det mesta av användargränssnittets logik är skriven i JavaScript, vilket skickar förfrågningar till servern (till exempel innehållet i ett e-postmeddelande). Den växande trenden för användning av Ajax-programmering utnyttjar på samma sätt denna teknik.

En JavaScript-motor (även känd som en JavaScript-tolkare eller JavaScript-implementering) är en tolk som tolkar JavaScript-källkod och exekverar skript därefter. Den första JavaScript-motorn skapades av Brendan Eich på Netscape Communications Corporation, för webbläsaren Netscape Navigator. Motorn, kallad SpiderMonkey, är implementerad i C. Den har sedan dess uppdaterats (i JavaScript 1.5) för att överensstämma med ECMA-262 edition 3. Rhino-motorn, skapad främst av Norris Boyd (tidigare Netscape, nu på Google) är en implementering av JavaScript i Java . Rhino, precis som SpiderMonkey, är ECMA-262 edition 3-kompatibel.

En webbläsare är den absolut vanligaste värdmiljön för JavaScript. Webbläsare skapar ofta icke-inbyggda, körtidsberoende objekt för att representera Document Object Model (DOM) i JavaScript. Webbservern är en annan vanlig tjänstemiljö. En JavaScript-webbserver exponerar vanligtvis sina egna objekt för att representera HTTP-förfrågnings- och svarsobjekt, som ett JavaScript-program sedan kan förhöra och manipulera för att dynamiskt generera webbsidor.

Eftersom JavaScript är det enda språket som de flesta populära webbläsare delar stöd för, har det blivit ett språk som många ramverk på andra språk kompilerar till, även om JavaScript inte var designat för sådana ändamål. Trots prestandabegränsningarna som är inneboende i dess dynamiska natur, har den ökade hastigheten hos JavaScript-motorer gjort detta språk till en förvånansvärt genomförbar kompileringsmiljö.

Skriptexempel

Här är ett kort exempel på en webbsida (som överensstämmer med standarderna för HTML5- standarden ) som använder JavaScript för DOM- hantering :

<!DOCTYPE html> 
< html > 
< head > 
    < meta  charset = "utf-8" > 
    < title > Enkelt exempel </ title > 
</ head > 
< body > 
    < h1  id = "header" > Detta är JavaScript </ h1 >

    < script > 
        dokument . kropp . appendChild ( document . createTextNode ( 'Hej världen!' ));
    
        var  h1  =  dokument . getElementById ( 'header' );  // innehåller referensen till taggen <h1> 
        h1  =  document . getElementsByTagName ( 'h1' )[ 0 ];  // åtkomst till samma <h1> element 
    </ script >

    < noscript > Din webbläsare stöder inte JavaScript, eller så är JavaScript inaktiverat. </ noscript > 
</ body > 
</ html >

Kompatibilitetsöverväganden

Eftersom JavaScript körs i så många olika miljöer är en viktig del av testning och felsökning att testa och verifiera att din JavaScript-kod fungerar korrekt i flera webbläsare. DOM-gränssnittet för att komma åt och manipulera webbsidor är inte en del av ECMAScript-standarden, eller JavaScript i sig. DOM definieras av standardiseringsarbetet från W3C , en oberoende organisation. I praktiken skiljer sig olika webbläsares implementeringar av JavaScript både från varandra och från standardens standarder.

För att komma till rätta med dessa skillnader kan JavaScript-författare ha kunnat skriva standardkompatibel kod som också skulle köras korrekt i de flesta webbläsare, eller om inte det, åtminstone skriva kod som kan kontrollera förekomsten av vissa webbläsarfunktioner och att den beter sig annorlunda om det sägs funktionalitet är inte tillgänglig. Det finns fall där två webbläsare kan implementera samma funktion, men med olika beteende, ett faktum som kan hjälpa programmerare att upptäcka vilken webbläsare som körs i det ögonblicket och därmed ändra beteendet för ditt skrivande så att det matchar. ​ Programmerare använder också ofta bibliotek eller verktyg som tar hänsyn till skillnaderna mellan webbläsare.

Dessutom kanske skripten inte fungerar för vissa användare. En användare kan till exempel:

• Använda en äldre webbläsare utan fullt stöd för DOM API,
• Använd en PDA- eller mobiltelefonwebbläsare som inte kan köra JavaScript
• Har JavaScript-körning inaktiverad, som en säkerhetsåtgärd,
• Användning av röstläsare på grund av till exempel synnedsättning.

För att stödja dessa användare skapar webbutvecklare ofta sidor som är feltoleranta baserat på användaragent (webbläsartyp) som inte stöder JavaScript. I synnerhet bör sidan fortfarande vara användbar utan de ytterligare funktioner som JavaScript skulle ha lagt till. Ett alternativt tillvägagångssätt som många tycker är att föredra är att först skapa innehåll med hjälp av tekniker som fungerar i alla webbläsare, och förbättra innehållet för användare som har aktiverat JavaScript.

Tillgänglighet

Förutsatt att användaren inte har inaktiverat körning av JavaScript-kod bör JavaScript på klientsidan skrivas både i syfte att förbättra upplevelserna för besökare med syn- eller fysiska funktionshinder, och för att undvika att dölja information från dessa besökare. ]

Skärmläsare , som används av blinda och synskadade, kan tas med i beräkningen av JavaScript och kan därmed komma åt och läsa DOM-elementen på sidan. Skriftlig HTML-kod bör vara så kortfattad, navigerbar och semantiskt rik som möjligt, oavsett om JavaScript körs eller inte.

JavaScript bör inte vara helt beroende av webbläsarmushändelser och bör vara tillgängligt för användare som inte vill använda musen (datorn) för att navigera eller som väljer att bara använda tangentbordet. Det finns enhetsoberoende händelser som onfocusoch onchangesom är att föredra i de flesta fall. ]

JavaScript får inte användas för att skapa förvirring eller desorientering för webbanvändaren. Till exempel att modifiera eller inaktivera normal webbläsarfunktionalitet, som att ändra sättet att navigera tillbaka-knappen eller uppdateringshändelsen beter sig, är metoder som vanligtvis är bäst att undvika. På samma sätt minskar utlösandet av händelser som användaren kanske inte är medveten om användarens känsla av kontroll och orsakar oväntade ändringar i sidinnehållet. ]

Ofta blir processen att tillhandahålla en komplex webbsida med högsta möjliga grad av tillgänglighet ett icke-trivialt problem där många frågor i slutändan debatteras och får åsikter, vilket kräver allas engagemang till slutet. Användaragenter och hjälpmedel för personer med funktionsnedsättning utvecklas dock ständigt, och nya riktlinjer och information fortsätter att läggas ut på webben. ]

Säkerhet

Se även: Webbläsarsäkerhet

JavaScript och DOM tillåter programmerare att missbruka det för att introducera skript som exekverar kod med skadligt innehåll utan användarens samtycke, vilket äventyrar användarsäkerheten.

Webbläsarutvecklare tar hänsyn till denna risk genom att använda två begränsningar. Först körs skripten i en sandlåda där endast webbrelaterade åtgärder kan utföras, inte generella programmeringsuppgifter som att skapa filer. För det andra begränsas det av samma ursprungspolicy: skript från en webbplats har inte tillgång till information som skickas till en annan webbplats (från en annan domän) såsom användarnamn, lösenord eller cookies. De flesta JavaScript-säkerhetsbrister är relaterade till brott mot någon av dessa två begränsningar.

Det finns projekt som AdSafe eller Secure ECMA script (SES) som ger högre säkerhetsnivåer, särskilt i kod skapad av tredje part (som annonser). ]

Content Secure Policy (CSP) är den primära metoden för att säkerställa att endast betrodd kod kan köras på en webbsida.

Sårbarheter över flera webbplatser

Ett vanligt säkerhetsproblem i JavaScript är cross-site scripting , eller XSS, ett brott mot samma ursprungspolicy. XSS-sårbarheter tillåter en angripare att injicera JavaScript-kod på webbsidor som användaren besöker. En sådan webbplats kan vara en bank, där angriparen kan komma åt bankapplikationen med offrets privilegier, som kan avslöja hemlig information eller överföra pengar utan offrets tillstånd. En lösning på XSS-sårbarheter är att använda HTML-escape när information från opålitliga källor visas.

Vissa webbläsare inkluderar partiellt skydd mot reflekterade XSS-attacker (angriparen är i samma webbförfrågan). Angriparen tillhandahåller en URL inklusive skadlig kod. Men även webbläsaranvändare är sårbara för andra XSS-attacker, till exempel de där skadlig kod lagras i en databas. Endast korrekt design av webbapplikationer på serversidan kan helt förhindra XSS. XSS-sårbarheter kan också uppstå på grund av exekveringsfel av webbläsarutvecklare. ]

En annan sårbarhet är förfalskning av begäranden på flera ställen eller CSRF. I CSRF lurar den attackerande webbplatsens kod offrets webbläsare, vilket gör att angriparen kan göra förfrågningar på offrets vägnar, vilket gör det omöjligt för målapplikationen (till exempel en bank som gör en pengaöverföring) att veta om begäran gjordes frivilligt av användaren eller av en CSRF-attack.

Attacken fungerar eftersom, om målwebbplatsen endast använder cookies för att autentisera offerförfrågningar, kommer förfrågningar som initieras av angriparens kod att ha samma legitima åtkomstuppgifter som användarinitierade förfrågningar.

Generellt sett är lösningen på CSRF att införa ett dolt formulärfält vars värde används för att utföra autentisering, och inte bara via cookies, på förfrågningar som kan få bestående effekter. Att kontrollera HTTP-hänvisningshuvudet kan också hjälpa.

"JavaScript-kapning" är en typ av CSRF-attack där en <script>-tagg på angriparens webbplats utnyttjar en sårbarhet på sidan på offrets webbplats som gör att den returnerar privat information, i form av JSON- eller JavaScript-kod. Möjliga lösningar är:

• att en autentiseringstoken krävs i parametrarna för POST- och GET-förfrågningar för de förfrågningar som kräver återlämnande av privat användarinformation.
• använd POST och GET aldrig för förfrågningar som returnerar privat information

Utvecklingsverktyg

I JavaScript blir det nödvändigt att ha en debugger när man utvecklar stora, icke-triviala applikationer. Eftersom det kan finnas implementeringsskillnader mellan olika webbläsare (särskilt när det gäller DOM), är det användbart att ha tillgång till en debugger för var och en av de webbläsare som vår webbapplikation kommer att rikta in sig på. ]

Webbfelsökningar är tillgängliga för Internet Explorer, Firefox, Safari, Google Chrome och Opera. ]

Det finns tre debuggers tillgängliga för Internet Explorer : Microsoft Visual Studio är den mest avancerade av de tre, tätt följt av Microsoft Script Editor (en komponent i Microsoft Office ) och slutligen Microsoft Script Debugger, som är mycket mer grundläggande än den andra två, även om det är gratis. Den kostnadsfria Microsoft Visual Web Developer Express IDE erbjuder en begränsad version av JavaScript-felsökningsfunktionen i Microsoft Visual Studio. Internet Explorer har inkluderat utvecklarverktyg sedan version 8 (visas genom att trycka på F12-tangenten). Webbapplikationer i Firefox kan felsökas med Firebug -tillägget eller den gamla Venkman-felsökaren. Firefox har också en grundläggande felkonsol inbyggd, som loggar och utvärderar JavaScript. Den loggar också CSS- fel och varningar. Opera innehåller en uppsättning verktyg som kallas Dragonfly. WebKits webbinspektör inkluderar en JavaScript-felsökning som används i Safari , tillsammans med en modifierad version av Google Chrome .

Det finns några hjälpverktyg för felsökning, även skrivna i JavaScript och byggda för att köras på webben. Ett exempel är programmet JSLint , utvecklat av Douglas Crockford , som har skrivit mycket om språket. JSLint analyserar JavaScript-kod så att den överensstämmer med en uppsättning standarder och riktlinjer för att säkerställa korrekt funktionalitet och underhållsbarhet.

Se även

• VBScript
• AJAX
• Webbapplikation
• Dokumentobjektmodell
• jQuery
• JSON
• HTML
• HTML5

Externa länkar

• Mozilla Developer Center .
• (på engelska) Javascript-handledning .
• JavaScript - Titta bakom kulisserna .