|  |  |
| --- | --- |
|  | *Ĉi tiu artikolo temas pri reta programlingvo. Por insulo rigardu la paĝon Javo. Por (homa) lingvo legu la artikolon Java lingvo. Por alia programlingvo disponeblas la paĝo Java (programlingvo). Koncerne aliajn signifojn aliru la apartigilon Java (apartigilo).* |

Strukturo de ioj Ĝavoskriptaj objektoj.
**JavaScript** (ankaŭ nomata **Ĝavoskripto** aŭ simple **JS**) estas plur-paradigma progamlingvo kaj havas karakterizaĵojn de ambaŭ funkciaj programlingvoj kaj objektemaj programlingvoj. Ĝi estas kreita en 1995.

Oficiale Ĝavoskripton difinas la normo *ECMA‑262*, alinome *ECMAScript*. La nuna versio de tiu normo estas la tria, sed la kvina versio de tiu normo projektas anstataŭigi ĝin.
La diversaj TTT-legiloj sufiĉe bone konformiĝas al tiu normo, sed ili kaŭzas programajn komplikojn pro malsimilaj adaptoj de la dokumentobjekta modelo (normo *dom*), tra kiu Ĝavoskripto manipulas la fenestrajn objektojn.

Uzo de la lingvo
----------------

Ĝin funkciigas TTT-legiloj. Por sekureco de personaj komputiloj ĝi ne povas skribi sur diskojn. Ĝi estas kiel infano, ludanta intern infana ĝardeno kaj ne scianta pri eksteraj aferoj.
Iam oni trovas, ke eĉ ĉe jam ekzistaj malpermesoj eblas krei per Ĝavoskripto danĝerajn programojn. Ekzemple, antaŭ kelkaj jaroj kelkaj TTT-legilaj versioj malpermesis, ke ĝavoskripta programo aperigu fenestrojn, kiuj estas tro malgrandaj, kvankam novaj fenestroj aperas ne ekster la TTT-legilo kaj ŝajnas, ke ili povas damaĝi nenion.

Utilo de la lingvo estas, ke dank ĝi TTT-legilo liberiĝas de revoki paĝon, se necesas tasko, en kiu konservendas nenio interreten (Ĝavoskripto meme faras la taskon, dank tio, ke Ĝavoskripto kapablas ŝanĝi bildon, kiu okupas TTT-legilan ekranon, kaj senti komandojn de homo). La plej ofta ĉi tia tasko: Ĝavoskripto kontrolas ĝuston de informacio, kiun homo provas sendi per TTT-legilo (Ĝavoskripto, ekzemple, insultas, se la homo tajpas vortojn en tabelon, en kiun endas tajpi nur nombrojn). Nature, la tasko, kiun faras Ĝavoskripto, indas esti ne tre malfacila, ĉar komputilo, en kiu lanĉitas TTT-legilo, eble estas ne sufiĉe forta (ekzemple, poŝkomputilo).

Ŝatantoj de Ĝavoskripto ricevis grandan ĝojon post apero de la 5a versio de HTML. En HTML5 aperis la kodero `canvas`, sur kiu oni povas desegni per Ĝavoskripto.

Unu el novaj uzoj de Ĝavoskripto estas malreale rigardi programojn por poŝtelefonoj sen lanĉi ilin en reala poŝtelefono.
Ĝavoskripto naskas TTT-legile bildon, kiu similas poŝtelefonajn aferojn.
Se en lanĉo nenio konservendas por uzati en estontaj lanĉoj, malreala lanĉo tute sufiĉas (ekzemple, poŝtelefonaj videoludoj). Bonas ideo verki programojn por ĉi tia rigardmaniero ne en speciala poŝtelefona lingvo, sed rekte Ĝavoskripte. Kial? Se eblas krei ilojn tradukantajn ĉi tiajn ĝavoskriptajn programojn en la specialajn poŝtelefonajn lingvojn, oni akiras la avantaĝojn:

1. Ekzistas nune multo da diferencaj poŝtelefonaj familioj: Android, "Symbian", iPad, ktp. Sama programo uzeblas por kelkaj familioj (necesas nur riĉa ilaro por traduki ĝavoskriptajn programojn plurdirekte)
2. Ĝavoskripton lerni (krome, plisimpligitan Ĝavoskripton, Ĝavoskripton sen povoj, neutilaj poŝtelefone) estas pli facile ol lerni specialajn lingvojn (Ĝavo, C++, ktp.)
3. Ne necesas krei ĝavoskripte programon, legantan tekstojn de aliaj programlingvoj, sufiĉas nur malpermesi kelkajn tro fortajn povojn de Ĝavoskripto.

Ekzistas ankaŭe unu malavantaĝo: Poŝtelefona programo, akirita traduke, ne funkcias tiom rapide kiom funkcius sama programo verkita rekte en speciala lingvo, sed la ideo modas nune.
Famas nune kelkaj ĉi tiaj manieroj verki ĝavoskriptajn programojn, ekzemple, Sencha Touch.

Ekzistas ankaŭ uzoj de Ĝavoskripto ne TTT-legile. Ie ĝin oni uzas intern Vindozo, ekzemple, sed ŝajnas, ke la plej fama uzo estas TTT-legila. Oni eĉ proponas inventi Ĝavoskripton en lernejojn anstataŭ tradiciajn programlingvojn por lerni algoritmojn. Simpleco de Ĝavoskripto kaj tio, ke oni bezonas neniun ilon krom TTT-legilon por lanĉi siajn programojn, estas avantaĝo (sed, nature, tio, ke TTT-legile malfacilas kontroli erarojn de programistoj, problemas lernejan uzon, necesas speciala, ne-TTT-legila, programado por sukcese instrui).

Ekzemploj
---------

Ĝavoskripto ne tipigas variablojn. Variablojn oni ne bezonas deklari por ke ili estu uzeblaj.

```
x = 1
x = "Hello World!"
y = x + 2
// "y" valoras "Hello World!2".

```

Vi povas vidi, ke, malsimile al Ĝavo, oni ne devas uzi punktokomojn inter komandoj, se la komandoj ne apartenas al la sama linio.
Krome, oni ne bezonas uzi punktokomon post komando, se la komando estas lasta.

Tiel en Ĝavoskripto oni deklaras funkciojn:

```
f = function(x, y) { return x (y) }

```

Vi povas vidi, ke funkcio povas esti argumento por alia funkcio (tra la argumento "x" oni povas meti funkcion).

Ekzistas ilo por stiri videblon de variablo ekster funkcio.
Ĉi tiu ilo estas la vorto `var`:

```
g = function(x, y) { s=x+y; var s; return s\*2}

```

La variablo `s` ne videblas ekster la funkcio g pro la komando "`var s`".

Objektoj
--------

Objektoj aperas en la lingvo tre simple. Ĉiu variablo povas ekhavi anojn, post ĉi tio ĝi estos objekto:

```
g={};
g.nomo=1

```

Sama senco:

```
g={nomo:1}

```

Vi vidas objekton kun unu ano: `nomo`. Se vi provos akiri, ekzemple, `g.agho`, komputilo respondos "`undefined`" (nedifinita), sed ne "`null`" (malplena).

Ĉiu variablo, ne apartenanta al objekto, estas reale ano de la speciala objekto *`window`* (t.n. "`global object`"). Do, oni povas akiri la variablon `g` ankaŭ per la nomo "`window.g`".

Ekzistas du vojoj por atingi anon de objekto. Ekzemple, por akiri la anon "`nomo`" de la objekto "g":

1. `g.nomo`
2. `g["nomo"]`

Dank'al la dua vojo oni povas rigardi akiron pri ano de objekto kiel funkcion, kies argumentoj estas la objekto kaj nomo de la ano:

```
function(g){
 for(i in g){
 alert(g[i]);
 }
}

```

Krome, la dua vojo permesas uzi kelkajn vortojn por nomi anojn:

```
ameriko={"suda parto":"Kubo","norda parto":"Usono"};
alert(ameriko["suda parto"]);

```

Krome, la dua vojo permesas uzi nombrojn por nomi anojn (speciala speco de objektoj, "`Array`" = tabelo):

```
teamo=["Johano","Paŭlo","Ringo","Georgo"];
alert(teamo[0]);

```

Ano de objekto povas esti funkcio. Funkcio povas koni objekton, kies ano ĝi nun estas, per la speciala nomo *`this`*.

Regionoj kaj Fermigo
--------------------

Rigardu ekzemplon, en kiu funkcio naskiĝis interne de alia funkcio:

```
v=function(){
 var g="Ĝise";
 var h=function(){
 alert(g);
 };
 g="Poste";
 return h;
};
v()();

```

Multaj homoj opinias, ke la skripto devontus mesaĝi "Ĝise".
Oni kutime pensas, imagante, ke post la funkcio `h` naskiĝas, la funkcio `h` ne dependas de la variablo `g`. Sed reale la skripto mesaĝas "Poste". Kvankam la variablo `g` ne videblas ekster la funkcio `v`, kreintoj de Ĝavoskripto permesis al la funkcio, kiun donas la funkcio `v`, uzi la variablon `g`. Do laŭ la difino de Ĝavoskripto eblas, ke rezulto de la funkcio `v` private posedas variablon. Ĉi tia variablaro, posedata private, nomiĝas "regiono" ("scope" en la angla).

Fermigo (angle: "Closure") estas tio, kio uzas la nomregionon. Ĝis morto de ĉiuj fermigoj, la ilo rubkolektilo (angle: "Garbage collector") ne rajtas liberigi memoron, kiun okupas fermigoj. En la lasta ekzemplo, la fermigo estas rezulto de la funkcio `v`, kiu estas ankaŭ funkcio.

Naski objektojn per la vorto *new*
----------------------------------

Kio okazos, se funkcio, kiu uzas la nomon *`this`*, estas nenies ano?
La vorto *`this`* signifos novan objekton, kiu naskiĝos pro voko de la funkcio:

```
virino=function(){
 this.vesto="robo";
};
onklino=new virino();

```

Atingi ĉi tiun objekton oni povas per la speciala vorto *`new`* (por ne konfuzi al rezulto de la funkcio, oni ĝin ne atingas per rekta voko "`onklino=virino()`", ĉar ĉi tiel oni povas atingi tion, kio lokiĝas post la vorto *`return`*, anstataŭ tion, kion signifis la nomo *`this`* interne de la funkcio).

Do ĉiu funkcio estas kiel klaso en Ĝavo, aperas parenceco inter objektoj.
Oni povas ekscii, ĉu objekto apartenas klason per la funkcio `instanceof`. Ekzemple: `onklino instanceof virino` estas `true`.

Reale, ĉiu simpla tipo en Ĝavoskripto estas klaso. Ekzistas klaso:

1. `String` = karaktraro
2. `Number` = nombro
3. `Boolean` = bulea
4. `Array` = tabelo
5. `Function` = funkcio
6. `Object` = objekto

Ekzemple, ĉiu objekto havas la anon `toString()`, kaj la primitivaj tipoj ne estas escepto (malkiel Ĝave):

```
a=3;
alert(a.toString());

```

Heredi
------

Ĉiu funkcio havas anon "prototype", en kiun oni povas meti objekton (ne funkcion!), kies ecojn ĉiuj idoj de la funkcio heredu. Ekzemple:

```
patrino=new virino();
patrino.okuloj="bluaj";
knabino=function(){
 this.karaktero="malbona";
};
knabino.prototype=patrino;
fratino=new knabino();
alert(fratino.okuloj);
//okuloj de fratino estas tiaj, kiaj estas okuloj de patrino ("bluaj")

```

Referencoj
----------

1. ↑  Javascript en Komputeko
2. ↑   Ŝangoj en la versio 1.8.5 de JavaScript.. Arkivita el la originalo je 2012-12-20. Alirita 2012-11-30.

Vidu ankaŭ
----------

* LibreJS

Eksteraj ligiloj
----------------

* Kategorio JavaScript en la Vikimedia Komunejo (Multrimedaj datumoj)

* angle Informoj ĉe developer.mozilla.org Arkivigite je 2010-07-02 per la retarkivo Wayback Machine


|  |  |
| --- | --- |
| Bibliotekoj | * PeEnEo: 52533
* GND: 4420180-1
* LCCN: sh96004880
* SUDOC: 034781870
* BNF: 12549978q
* NKC: ph117651
* BNE: XX542465
 |