**JavaScript** (edo **JS**) goi-mailako programazio-lengoaia bat da, Web-nabegatzaileak definitzeko ECMAScript espezifikazio estandarrarekin bat datorrena. Hiru programazio-paradigmarekin erabil daiteke: objektuetara bideratutako programazioa, programazio inperatiboa eta programazio funtzionala.

Web-orri interaktiboak sortzeko aproposa da eta funtsezkoa web-aplikazioetan. Webgune gehienek erabiltzen dute eta web-nabigatzaile hedatuenek dute hura exekutatzeko motorra. HTML eta CSSrekin batera Webaren oinarrizko hiru teknologietako bat da.

Script-lengoaia bat da, atazen exekuzioa ingurune berezietan automatizatzeko diseinatua.

Sintaxi aldetik C eta Java programazio-lengoaien antza du eta izenez Java eta JavaScript oso antzekoak izan arren, ez dira nahastu behar; semantika aldetik lengoaia desberdinak baitira eta helburu desberdinarekin diseinatuak izan baitziren.

Historia
--------

1995. urtean Netscape Communications enpresak Brendan Eich kontratatu zuen, Scheme programazio-lengoaia bere Netscape nabigatzailean txertatzeko. Aurretik, Netscape Communications enpresako kideak Sun Microsystems enpresakoekin elkarlanean aritu ziren haren Java programazio-lengoaia Netscape nabigatzailean gehitzeko eta Microsoft enpresarekin lehiatzeko web-teknologien eta plataformen hedapenean. Azkenean, Netscape Communications enpresako arduradunek Perl, Python, TcL edo Scheme lengoaiak baztertu eta script programazio-lengoaia berri bat sortzea erabaki zuten, Java osatu eta haren antzeko sintaxia izango zituena. Antzeko proposamenak sortuko ziren beldurrez, lehia-giro horretan haien ideia babesteko modu onena prototipo bat azkar sortzea zela pentsatuta, Eich-ek JavaScript-en lehen prototipoa 10 egunetan garatu zuen, 1995eko maiatzean.

Lengoaia berriak hasierako garapenean **Mocha** izena hartu bazuen ere, 1995eko irailean *Netscape Navigator 2.0* nabigatzailearen *beta* bertsioetan erabilia izan zenean, **LiveScript** izendatua izan zen ofizialki. Gerora, 1995eko abenduan, *Netscape Navigator 2.0 beta 3* bertsioan banatua izan zenean, **JavaScript** izenez berrizendatua izan zen.

Microsoft-ek 1996an argitaratu zituen bere script-teknologiak, VBScript eta JScript, bere Internet Explorer nabigatzailean erabiltzeko. CSSrako eta HTMLrako euskarrien garapenean ere ari zen Microsoft, baina Netscape Navigator nabigatzailean erabiltzen zirenekin alderatuta, oso desberdinak ziren. Garai hartako diseinatzaileentzat eta programatzaileentzat oso zaila gertatzen zen bi nabigatzaileetan ondo ikusteko moduko webguneak sortzea, teknologiak ez zirelako bateragarriak.

Bi enpresen eta haien nabigatzaileen arteko lehia izugarria zen. Testuinguru horretan sortu zen Dokumentuaren Objektu Eredua (DOM). W3C erakundeak kudeatzen duen objektu estandarren multzo bat da, HTML eta XML dokumentuak erakusteko erabiltzen dena.

Web-teknologien bateraezintasun arazo horiek ikusita, *Netscape Communications* enpresak estandar-etaz arduratzen den *Ecma International* erakundearekin harremanetan jartzea erabaki zuen 1996ko azaroan. JavaScript bidali zion, hark espezifikazio estandar bat lantzeko. Netscape-k egindako lanean oinarrituz estandar bat sortzea zen helburua, beste enpresek haien nabigatzaileak estandarrari jarraituz inplementatzeko eta webguneetan erabilitako teknologien bateragarritasuna lortzeko. Horrela, 1997an sortu zen ECMAScript espezifikazio estandarraren lehen bertsioa, *ECMA-262*, JavaScript-en oinarritutakoa. ActionScript eta JScript programazio-lengoaiak ere ECMAScript espezifikazio estandarraren inplementazioak izan ziren. ISO estandarra ere badu, ISO/IEC 16262.

Hori guztia gertatzen ari zen bitartean, JavaScript lengoaiaren aukerak aztertzen zebilen web-teknologietarako garatzaileen komunitatea. 2005ean Jesse James Garrett-ek "*Ajax: A New Approach to Web Applications*" artikuluan erabili zuen lehen aldiz Ajax terminoa, web-teknologia multzo bati buruz hitz egiteko. Teknologia horien muina JavaScript lengoaia zen eta haiei esker Web-erako aplikazio dinamikoak sortzea posiblea gertatu zen, web-orrietan datuak kargatzeko aukera ematen zutenak, web-orriak behin eta berriz kargatzen ibili gabe.

Ajax teknologiek eragindako iraultzak bultzada handia eman zion JavaScript programazio-lengoaiari, Internet-eko programazio-lengoaia ezagunenetako bat bihurtzeraino.

Erabilera web-orrietan
----------------------

JavaScript, normalean, HTML orrietan txertatutako funtzioak idazteko erabiltzen da. Funtzio horiek eta web-orriaren DOM-ak elkarri eragiten diote. Hona hemen JavaScript web-orrietan txertatzeari esker lor daitezkeen funtzionaltasun batzuk:

* Web-orrian eduki berria kargatzea edo web-zerbitzarira datuak bidaltzea Ajax erabiliz, web-orria birkargatzeko beharrik izan gabe.

* Web-orrietako elementuen animazioa egitea: desagertu araztea, tamaina aldatzea, mugitzea, etab.

* Web-orrietan audioa edo bideoak erreproduzitzea, eta eduki interaktiboa txertatzea: jokoak, etab.

* Web-inprimaki batean sartutako datuak balioztatzea, web-zerbitzarira bidali aurretik onargarriak direla ziurtatzeko.

* Erabiltzaileek irakurri ohi dituzten web-orriei buruzko informazioa zerbitzarira bidaltzea. Web-orrietan halako kontrolak txertatu ohi dira, Web-analisia egiteko, iragarkien segimendua egiteko, web-orriak pertsonalizatzeko, etab.

HTML kodearekin bakarrik hauteman ezin diren ekintzak hauteman daitezke bertan JavaScript kodea txertatuz, adibidez, erabiltzaileak teklaren bat sakatu izana. Horrek izugarrizko aukerak eskaintzen dizkie gmail moduko aplikazioei, posiblea gertatzen delako mezu elektroniko baten edukiarekin web-zerbitzarira eskariak bidaltzea. Gaur egun, hori da neurri handi batean erabiltzaile-interfazeak inplementatzean erabiltzen den logika. Ajax programazio-lengoaia ere gero eta gehiago erabiltzen da web-aplikazioetan, eta harekin ere antzeko teknikak erabiltzen dira erabiltzailearen ekintzei buruzko informazioa transmititzeko. Gainera, JavaScript kodea eraginkorra da, erabiltzailearen nabigatzailean modu lokalean exekuta daitekeenez urruneko zerbitzarian exekutatu gabe, erabiltzailearen ekintzei azkar erantzun diezaiekete.

JavaScript kodean idatzitakoa interpretatu egin behar da exekutatu ahal izateko. *JavaScript motor* esaten zaio JavaScript iturburu-kodearen interpretatzaileari. *JavaScript interpretatzaile* edo *JavaScript inplementazio* izenak ere hartzen ditu. Lehenengo JavaScript motorra Brendan Eich-ek sortu zuen Netscape Communications-en, *Netscape Navigator* web-nabigatzailearentzat. Badira beste JavaScript motor gehiago. SpiderMonkey adibidez, Mozilla Firefox nabigatzailean erabiltzen den JavaScript motorra da eta hasiera batean C programazio-lengoaian inplementatuta bazegoen ere, gerora JavaScript-era pasa zen ECMA-262 espezifikazio estandarra betetzeko. Rhino beste motor bat da, Netscape Communications-ek garatua; Java-n idatzitako Javascript motorra da.

Web-nabigatzaileak dira JavaScript-en ostalaririk ohikoenak. Web-nabigatzaileek natiboak ez diren objektuak sortzen dituzte, exekuzio-ingurunearen mende daudenak, Dokumentuaren Objektu Eredua (DOM) JavaScript-en errepresentatzeko. Web-zerbitzariak ere JavaScript-en ohiko ostalariak dira; objektu propioak eskaintzen dituzte, HTTP eskaerak eta erantzun objektuak errepresentatzeko; horrela, JavaScript programa batek galdetu eta manipulatu ahal izango lituzke, web-orriak dinamikoki sortzeko.

JavaScript eta Java
-------------------

JavaScript eta Java programazio-lengoaiek hain antzeko izenak eta sintaxiak izateagatik, antzeko lengoaiak direla pentsatzera eraman dezake. Bi lengoaiak sortu ziren 1995. urtean, Sun Microsystems enpresako James Gosling-ek sortu zuen Java eta Netscape Communications enpresako Brendan Eich-ek JavaScript. Javaren hitz erreserbatuak mantendu ziren JavaScript diseinatu zenean eta Java-ren liburutegi estandarrak kontuan hartuz diseinatu ziren JavaScript-enak.

Baina antzekotasun horiek eta beste zenbait aparte utzita, haien artean dituzten diferentziek oso lengoaia desberdinak egiten dituzte. Batzuk aipatzearren, hona hemen nagusienak:

* Java-k datu-moten kontrol estatikoa (*static typing*) egiten du. Iturburu-kodea aztertzen du, eta kontrola gaindituz gero, datu-motekin erlazionatutako ezaugarri batzuk beteko direla bermatzen du. JavaScript-ek datu-moten kontrol dinamikoa (*dynamic typing*) egiten du; exekuzio garaian egiten du datu-moten kontrola.
* Java programak bytecode edo kode eramangarri moduan kargatzen dira. JavaScript programak, aldiz, erabiltzaileak idatzitako iturburu-kode formatuan.
* Java-ko objektuak klaseetan oinarritzen dira, JavaScript-enak aldiz prototipoetan.
* Java-k ez zuen jasaten programazio funtzionala, Java 8 sortu zen arte. JavaScript-ek aldiz hasieratik jasaten du, Scheme programazio-lengoaiaren eraginagatik.

Ezaugarriak
-----------

Hona hemen ECMAScript estandarrarekin bat datozen inplementazioen ezaugarri nagusiak:

* Paradigma anitzeko programazio-lengoaia da. Programazio estilo bat baino gehiagorekin programak egitea onartzen du. Horrela, programatzaileak kasu bakoitzean bere beharretara hobe egokitzen den paradigma aukera dezake.
* Objektuetara bideratutako programazioa (prototipoetan oinarritua). Programazio-paradigma horretan, programak objektuetan oinarritzen dira. Objektuak ekintzen edo izateen abstrakzioak dira, haien ezaugarri edo propietateak *atributuen* bidez adierazten dira eta haien portaera *metodoetan* ematen da. Objektuetara zuzendutako programazioa klaseetan oinarritzen denean, objektuek komunean dituzten propietate eta metodoak *klaseetan* biltzen dira. Klase bat txantiloi bat da, objektuak sortzeko eredu bat. Horrela, objektu bakoitza klase baten instantzia bat dela esaten da. Baina Javascript ez dago klaseetan oinarrituta, prototipoetan baizik. Horrek esan nahi duena da, objektuak klonatuz sortzen direla objektu berriak.
* Programazio funtzionala jasaten du. Funtzioak objektuak dira, eta gainerako objektuek bezala astributuak eta metodoak dituzte.
* Programazio inperatiboa eta egituratua jasaten ditu. C-tik jaso du programazio egituraturako sintaxi gehiena: `if` egiturak, `while` begiztak, `switch` sententziak, `do while` begiztak, etab.
* Datu-moten esleipena dinamikoa da. Aldagai batek duen balioa une batean zenbakizkoa izan daiteke eta beste uneren batean karaktere-kate edo string-a. Erabiltzen den eragiketaren arabera, aldagaiaren datu-mota alda daiteke.

* Lengoaia interpretatua da. Aginduak banan-banan egikaritu daitezke, aldez aurretik konpiladore batek programa osoa konpilatu gabe.

Lengoaiaren ezaugarri horiek kontuan hartzen dira beste lengoaiekin konparatzen denean.

### Datu Motak

Aldagaiei hasierako balio bat esleitzen zaie, hori eginez, aldagai horri balioaren mota ezartzen zaio.

**JavaScript**-en horrela adierazten dira esleipenak:

```
var zenb = 0;

```

Esleitu eta gero, horrela aldatzen dira aldagaiak:

```
zenb = 2;

```

#### Datu mota bakunak

**JavaScript**-ek ondorengo oinarrizko datu motak ezagutzen ditu:

* Boolearrak:

Bi balio bakarrik onartzen ditu: false (faltsua) eta true (egiazkoa).

```
var egiazkoa = true;

var faltsua = false;

```

* Zenbakiak:

Adibidez: 10, 0.8, -4.2...

```
var zenbakia = 5;

var zenbakianeg = -5;

```

* Karaktere kateak edo string-ak:

Adibidez: 'Kaixo mundua!', 'Egunon'...

```
var nireIzena = "Izen bat";

var karakterea= "F";

```

#### Datu mota egituratuak

Hauek dira **JavaScript**-en datu mota egituratuak:

* Bektoreak

Objetuak dira, metodo eta propietateak dituzte, non programatzaileak edozein unetan erabil ditzake. Adibidez: (0, 2, 4).

```
var nireArray = new Array(1, 3, 5);

var besteArray = new Array();

var nireArray = new Array[1, 3, 5];

var besteArray = [];

```

* Objetuak

```
var nireObjetua = new Object();

var nireObjetua = {};

```

### Agindu motak

**JavaScript**-en oinarrizko aginduak  bi dira, balioen esleipena (var a = 2) eta datu-idazketak (print).

Datuen irakurketa aldiz, input funtzioa erabiltzen da.

### Kontrol Egiturak

#### Baldintzapeneko egiturak

Batzuetan, kode bloke batean, exekuzio fluxua kontrolatzea interesatzen zaigu alternatibak ezarriz, hau da, zenbait adierazpen baldintza baten arabera exekutatzen direla. Hori ahalbidetzeko baldintza egitura ezberdinak ezberditzen ditugu.

##### If..Else

Baldintza bat betetzen den egiaztatzeko IF egiturak erabiliko ditugu. Kontrol egitura mota hau programazio lenguia guztietan aurkitzen da.

```
if (kondizioa) {
 kodea\_A;
} else {
 kodea\_B;
}

```
Azter dezagun beraz adibide hau. IF baldintza esprisio boolear baten bidez adierazten da, hau da, lehenengo baldintza betetzen bada jarraian duen kode zatia exekutatuko du (giltzen artean aurkitzen den kodea). Baldintza hau ez bada betetzen eta else adarra baldin badago, adar honetan dagoen kodea exekutatuko da. Else adarrik ez badago ordea, egitura hau bukatutzat ematen da eta ez da ezer gehiago egingo. Else adarra hautazko adarra da. Esaterako jarraian ikus daitekeen adibide kodean ez da else adarrik erabiltzen, if egitura sinplea da:

```
if (n < 0) {
 n = -n; // balio absolutua
}

```
Beste zati honetan berriz egitura osoa ikus dezakegu:

```
// zenbaki handiena kalkulatzeko
var a = prompt("sakatu bi zenbakietako bat: ");
var b = prompt("sakatu bestea: ");
var hand;

if (a > b) {
 hand = a;
} else {
 hand = b;
 console.log("Handiena", hand);
}

```
Ondoko nabardura hauek hartu azpimarratu behar dira: Elif adarra else adarraren oso antzekoa da. Adar honek, hasierako baldintza betetzen ez bada, beste baldintza bat betetzen den egiaztatuko du. Bigarren baldintza hau betetzen bada dagokion kodea exkutatuko da. Erabiltzaileak nahi adina elif adar erabil ditzake.

```
if (ordua < 12) {
 console.log("Egun on");
} else if (ordua < 20) {
 console.log("Arratsaldeon");
} else {
 console.log("Gabon");
}

```

##### Switch

Ikusi dugun bezala if-elif-else ri esker une bakoitzean baldintza batzuen arabera nola jokatu aukera dezakegu. Batzuetan ordea balio batzuen artean bakarrik aukeratu nahi dugu, eta dagokion kodea exekatu aldagai batzuen balioa eta funtzio batek itzultzen duen balioaren arabera. Kodea garbi eta irakurgarri mantentzeko, ainbat if kasu erabili ordez switch-case erabil dezakegu:

```
switch (variable) {
 case balioa1:
 // 1 balioarentzako kodea
 break;
 case balioa2:
 // 2 balioarentzako kodea
 break;
 case balioa3:
 case balioa4:
 case balioa5:
 // 3, 4 eta 5 baioentzako kodea
 break;
 default:
 // aurreko balioetako bat ez bada exekutatu kode hau
}

```
Adibide honetan, aldagaiaren zenbait balio egiaztatzen ditugu, eta, horrela, bakoitzak egoera desberdinen arabera kode desberdin bat exekutatzeko aukera ematen du. Orain, value3, value4 eta value5 aztertzen baditugu, value5 azpian agertzen den kodea soilik exekutatuko dela ondoriozta dezakegu, gainontzeko balioak hutsik daudelako, baina baita hausteko klausula (break) ez dutelako. Erreserbatutako hitz honek Javascript kodea exekutatzen duen puntuan mozten du, kodean dagoen blokea utziz. Horrek ere lagunduko digu, adibidez, begizten kasuetan.

Honekin, switch kodea baldintzez baliatuz exekutatu dezakegu, baina if batekin egin behar ditugun eragiketa konplexurik gabe. Hala ere, switch ezin da inoiz ordezkatu if bategatik, alderantziz gerta daitekeen bezala.

##### Operadore logikoak eta erlazionalak

Baldintzak sortzeko, bi elementu berri erabili behar ditugu: eragile logikoak eta eragile erlazionalak. Eragile logikoak 3 dira.

| Eragile Logikoak |
| --- |
| Operadorea | Esanahia |
| && | Eta |
| || | Edo |
| ! | Ez |

6 eragile erlazional ezberdintzen dira.

| Eragile Erlazionalak |
| --- |
| Operadorea | Esanahia |
| == | Berdin |
| < | Txikiago |
| > | Handiago |
| <= | Txikiago edo berdin |
| >= | Handiago edo berdin |
| != | Ezberdin |

Eragile erlazionalak erabiliz baldintza errazak sor ditzakegu, gero baldintza konplexuagoak ere eratu ditzakegu operadore logikoak erabiliz. Adibidez:

```
if (adina > 6 && adina < 12) {
 alert("Umea zara");
} else if (adina >= 12 && adina < 18) {
 alert("Eres un adolescente");
} else if (adina >= 18 && adina < 31) {
 alert("Nerabe bat zara");
} else if (adina >= 31 && adina < 60) {
 alert("Heldu bat zara");
} else if (adina >= 60) {
 alert("Heldu zaharragoa zara");
} else {
 alert("6 urte baino zaharragoa ez den haurra izan behar duzu");
}

```

#### Iterazio-egiturak

Programazioan, begizta baten instrukzio blokea exekutatzen denean, iterazioa gertatu dela esaten da. Iterazio hauei esker instrukzio blokea behin eta berriz errepika dezakegu, agindu guzti hauek berriz idatzi gabe. Javascriptek bi iterazio mota bereizten ditu, *while* iterazioa eta *for* iterazioa.

##### *while* kontrol-egitura

Egitura errepikakor (loop) orokorrena while da. Adibide honetan erabilera sinplea azaltzen da:

```
while (iterazioa\_jarraitzeko\_baldintza) {
 // aginduak
}

```
Baldintza honek, emandako baldintza exekutatuko du emandako espresioa egia den bitartean.

Kontrol iterazio honek break eta continue espresioak aitortzen ditu.

##### *do...while* kontrol egitura

do...while aginduak emandako adierazpena exekutatuko du emandako baldintza bete izanez gero.

Hala ere, while instrukzioa ez bezala, kontrol egitura honek beti exekutatuko du emandako adierazpena, gutxienez behin.

```
do {
 c += 1;
} while (c < 10);

```

##### *for* kontrol-egitura

Agindu honek iterazioaren baldintzari buruz kontrol gehio baimentzen du. Hasierako espresioa behin exekutatzen da, eta baldintza beti aztertzen da iterazioaren hasieran

Biraren bukaeran, egindako aldaketak exekutatzen dira beti baldintza aztertu baino lehen. Horrela adierazten da for agindua:

```
for ("Hasierako espresioa"; "Baldintza"; "Amaierako espresioa") {
 // exekatu beharreko kodea
}

```

Adibidez: 

```
var c;

for (c = 0; c < 10; c += 1) {
 //aginduak
}

```

##### *break* eta *continue* aginduak

Baldintzazko egituren antzera iterazioetan ere break eta continue aginduak erabiltzeko aukera dugu. *break* aginduak begiztaren exekuzioan bat-bateko amaiera eragiten du, *continue* aginduak berriz, baldintza egiaztatzen du begizta berrabiarazi baino lehen.

### Funtzioak

Funtzioa, helburu edo zeregin espezifiko bat betetzeko egin beharreko agindu multzoa da. Helburu konplexuak zeregin sinpleagoetan zatitzea ahalbidetzen du, scriptak kudeatzea eta mantentzea errazten dutenak. Parametro edo argumentu bat funtzio batera igortzen diren datuak dira, egin beharreko ekintza burutzeko. Funtzioak zero argudio edo gehiago pasa daitezke. Funtzioa bat, funtzio horri scriptaren, orrialde beraren edo kanpoko orrialdeko edozein lekutatiik deitzen zaionean exekutatzen da. Funtzioak beti ziurtatuta daude exekutatutakoan balioren bat itzultzeko. Egikaritutakoan funtzio batera igorritako datuak funtzioaren sarrera gisa ezagutzen dira eta funtzio exekutatu batetik itzultzen den balioa funtzioaren irteera bezala ezagutzen da.

**JavaScript**-en berezitasunetako bat, zera da, azpiprogramak ez dituela.

Hona hemen adibide batzuk:

```
function hello() {
 alert("Hello, World!");
}

```

```
function stepToFive(number) {
 if (number > 5) {
 number -= 1;
 }
 if (number < 5) {
 number += 1;
 }
 return number;
}

```

Sintaxia eta semantika
----------------------

Hizkuntzaren azkeneko bertsioa ECMASCript 2016 da, 2016ko uztailaren 17an publikatua.

**JavaScript**-en, aldagaiak var hitza erabiltzen definitzen dira:

### Aldagaiak

```
var x; // x aldagaia definitzen du, nahiz eta baliorik ez eman

var y = 2; // y aldagaia definitzen du, eta 2 balioa ematen dio

```

Xehetasunak adierazteko,bi barra diagonal erabiltze dira, gorako adibidean bezala.

Ez dira existitzen Input/output funtzionalitateak lengoaia honetan, exekuzioak ematen digulako aukera hori. Hala eta guztiz ere, exekuzio ingurune gehienek, 'console' izeneko objektu bat dauka, ausazko fluxu irteeran inprimatuko duena.

```
console.log("Hello world!");

```

### Funtzio errekurtsibo bat

```
function factorial(n) {
    if (n == 0) {
        return 1;
   }
   return n \* factorial(n - 1);
}

```

### Lambda funtzioko adibideak (edo funtzio anonimoak)

```
var displayClosure = function() {
    var count = 0;
    return function () {
        return ++count;
    };
}
var inc = displayClosure();
inc(); // Itzultzen du 1
inc(); // Itzultzen du 2
inc(); // itzultzen du 3

```

### Dei automatikoko espresioak

Funtzioei aldagaiak parametro bezala ematea eskeintzen du

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

getValue(); // 1

```

Erreferentziak
--------------

1. ↑   **(Gaztelaniaz)** «Acerca de JavaScript» *Documentación web de MDN* (Noiz kontsultatua: 2019-12-30).
2. ↑   **(Ingelesez)** «JavaScript» *MDN Web Docs* (Noiz kontsultatua: 2019-12-27).
3. ↑   Severance, Charles.  (2012-02). «JavaScript: Designing a Language in 10 Days» *Computer* 45 (2): 7–8. doi:10.1109/MC.2012.57. ISSN 0018-9162. (Noiz kontsultatua: 2019-12-27).
4. ↑  (ingelesez) YouTube,   *Brendan Eich - CEO of Brave.*  (Noiz kontsultatua: 2019-12-27).
5. ↑  Netscape and Sun announce JavaScript, the Open, Cross-Platform Object Scripting Language for Enterprise Networks and the Internet, «Press Release» *web.archive.org* 2007-09-16 (Noiz kontsultatua: 2019-12-27).
6. ↑   «JavaScript: How Did We Get Here? - O'Reilly Media» *web.archive.org* 2016-07-19 (Noiz kontsultatua: 2019-12-27).
7. ↑  ECMAScript Programming Language Specification Standard «Standard ECMA-262» *www.ecma-international.org* (Noiz kontsultatua: 2019-12-27).
8. ↑  ECMAScript language specification **(Ingelesez)** 14:00-17:00. «ISO/IEC 16262:2011» *ISO* (Noiz kontsultatua: 2019-12-27).
9. ↑   **(Ingelesez)** «Details of the object model» *MDN Web Docs* (Noiz kontsultatua: 2019-12-30).

Ikus, gainera
-------------

* Programazio-lengoaien arteko konparazioa
* Java (programazio-lengoaia)
* HTML5
* HTML
* CSS

Kanpo estekak
-------------

* Javascript programazio-lengoaia Xabier Larrañaga Cendoya, IRALE (Irakasleen Euskarazko Prestakuntza Zerbitzua) 2014.
* HTML5, CSS eta JavaScript Irantzu Sagarna, IRALE (Irakasleen Euskarazko Prestakuntza Zerbitzua) 2018.
* JavaScript oinarrizko gida Gorka Alustiza,
* **(Ingelesez)** JavaScript (JS) JavaScript tutorialak eta baliabideak
* **(Ingelesez)** ECMA International, ECMA-262, ECMAScript Language Specification
* **(Ingelesez)** The Modern JavaScript Tutorial
* **(Ingelesez)** javascript.com

|  |  |
| --- | --- |
| Autoritate kontrola | 
* **Wikimedia proiektuak**
* Wd Datuak: Q2005
* Commonscat Multimedia: JavaScript
* MediaWiki MediaWiki: JavaScript

---

* **Identifikadoreak**
* BNE: XX542465
* BNF: 12549978q (data)
* GND: 4420180-1
* LCCN: sh96004880
* NKC: ph117651
* SUDOC: 034781870
* **Hiztegiak eta entziklopediak**
* Britannica: url

 |

* Wd Datuak: Q2005
* Commonscat Multimedia: JavaScript
* MediaWiki MediaWiki: JavaScript