JavaScript

**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 
thumb|'HTML5 lengoaia eta JavaScript APIak' liburua.
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:
```javascript
var zenb = 0;
```

Esleitu eta gero, horrela aldatzen dira aldagaiak:
```javascript
zenb = 2;
```

#### Datu mota bakunak 
**JavaScript**-ek ondorengo oinarrizko datu motak ezagutzen ditu:

* Boolearrak:

Bi balio bakarrik onartzen ditu: false (faltsua) eta true (egiazkoa).
```javascript
var egiazkoa = true;

var faltsua = false;
```

* Zenbakiak:

Adibidez: 10, 0.8, -4.2...
```javascript
var zenbakia = 5;

var zenbakianeg = -5;
```

* Karaktere kateak edo string-ak:

Adibidez: 'Kaixo mundua!', 'Egunon'...
```javascript
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).

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

var besteArray = new Array();

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

var besteArray = [];
```

* Objetuak

```javascript
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.
```javascript
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:
```javascript
if (n  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.
```javascript
if (ordua  6 && adina = 12 && adina = 18 && adina = 31 && 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:
```javascript
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.
```javascript
do {
    c += 1;
} while (c  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 
```javascript
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.

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

### Funtzio errekurtsibo bat 
```javascript
function factorial(n) {
    if (n == 0) {
        return 1;
   }
   return n * factorial(n - 1);
}
```

### Lambda funtzioko adibideak (edo funtzio anonimoak) 
```javascript
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
```javascript
var v;
v = 1;
var getValue = (function(v) {
  return function() {return v;};
}(v));
v = 2;

getValue(); // 1
```

## Erreferentziak 
## 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, https://blogak.eus/
*  JavaScript (JS) JavaScript tutorialak eta baliabideak
*  ECMA International, ECMA-262, ECMAScript Language Specification
*  The Modern JavaScript Tutorial
*  javascript.com