JavaScript

Nu confundați cu Java (limbaj de programare).

JavaScript
Unofficial JavaScript logo
JavaScript
Extensii fișiere	js mjs
Paradigmă	Multi-paradigmă: scripting, obiect-orientat (prototype-based), imperative, functional
Apărut în	1995 (1995)
Proiectat de	Brendan Eich
Dezvoltator	Netscape Communications Corporation, Mozilla Foundation
Ultima versiune	1.8.5/ 22 martie 2011 (2011-03-22)
Tipare	dynamic, duck
Implementări majore	KJS, Rhino, SpiderMonkey, V8, Carakan, Chakra
Influențat de	Scheme, Self, Java, C
Influențe	ActionScript, CoffeeScript, Dart, JScript .NET, Objective-J, QML, TypeScript, Node.js, LiveScript
Tip MIME	text/javascript application/x-ecmascript application/x-javascript text/javascript1.0 text/javascript1.1 text/javascript1.2 text/javascript1.4 text/javascript1.3 text/javascript1.5 text/livescript text/x-ecmascript text/x-javascript
JavaScript la Wikibooks

JavaScript
Extensie de fișier	.js
Tip MIME	application/javascript text/javascript (obsolete)
UTI	com.netscape.javascript-source
Tipul formatului	Limbaj de scripting

JavaScript (JS) este un limbaj de programare orientat obiect bazat pe conceptul prototipurilor. Este folosit mai ales pentru introducerea unor funcționalități în paginile web, codul JavaScript din aceste pagini fiind rulat de către browser. Limbajul este binecunoscut pentru folosirea sa în construirea siteurilor web, dar este folosit și pentru accesul la obiecte încapsulate (embedded objects) în alte aplicații. A fost dezvoltat inițial de către Brendan Eich de la Netscape Communications Corporation sub numele de Mocha, apoi LiveScript, și denumit în final JavaScript.

În ciuda numelui și a unor similarități în sintaxă, între JavaScript și limbajul Java nu există nicio legătură. Ca și Java, JavaScript are o sintaxă apropiată de cea a limbajului C, dar are mai multe în comun cu limbajul Self decât cu Java.

Până la începutul lui 2005, ultima versiune existentă a fost JavaScript 1.5, care corespunde cu Ediția a 3-a a ECMA-262, ECMAScript, cu alte cuvinte, o ediție standardizată de JavaScript. Versiunile de Mozilla începând cu 1.8 Beta 1 au avut suport pentru E4X, care este o extensie a limbajului care are de a face cu XML, definit în standardul ECMA-357. Versiunea curentă de Mozilla, 1.8.1 (pe care sunt construite Firefox și Thunderbird versiunile 2.0) suportă JavaScript versiunea 1.7.

Java, JavaScript și JScript

Schimbarea numelui din LiveScript în JavaScript s-a făcut cam în același timp în care Netscape încorpora suport pentru tehnologia Java în browserul web Netscape Navigator.

Microsoft a implementat limbajul JavaScript sub numele de JScript, cu o serie de modificări și extensii față de implementarea Netscape. Pe platforma Windows, JScript este unul din limbajele executabile de către Windows Script și, deci, poate fi folosit pentru scriptarea aplicațiilor ce suportă Windows Script, de exemplu Internet Explorer, sau chiar sistemul de operare Windows.

Asociația ECMA a standardizat limbajul JavaScript/JScript sub numele ECMAScript (standardul ECMA-262)

Utilizare

Cea mai des întâlnită utilizare a JavaScript este în scriptarea paginilor web. Programatorii web pot îngloba în paginile HTML script-uri pentru diverse activități cum ar fi verificarea datelor introduse de utilizatori sau crearea de meniuri și alte efecte animate.

Browserele rețin în memorie o reprezentare a unei pagini web sub forma unui arbore de obiecte și pun la dispoziție aceste obiecte script-urilor JavaScript, care le pot citi și manipula. Arborele de obiecte poartă numele de Document Object Model sau DOM. Există un standard W3C pentru DOM-ul pe care trebuie să îl pună la dispoziție un browser, ceea ce oferă premiza scrierii de script-uri portabile, care să funcționeze pe toate browserele. În practică, însă, standardul W3C pentru DOM este incomplet implementat. Deși tendința browserelor este de a se alinia standardului W3C, unele din acestea încă prezintă incompatibilități majore, cum este cazul Internet Explorer.

O tehnică de construire a paginilor web tot mai întâlnită în ultimul timp este AJAX, abreviere de la „Asynchronous JavaScript and XML”. Această tehnică constă în executarea de cereri HTTP în fundal, fără a reîncărca toată pagina web, și actualizarea numai anumitor porțiuni ale paginii prin manipularea DOM-ului paginii. Tehnica AJAX permite construirea unor interfețe web cu timp de răspuns mic, întrucît operația (costisitoare ca timp) de încărcare a unei pagini HTML complete este în mare parte eliminată. JavaScript este cu adevărat un limbaj dinamic. Rar este necesar să utilizați operatorul de evaluare pentru lucruri de genul acesta, pentru că, practic, puteți scrie orice doriți, dacă sintaxa este corectă și dacă ceea ce ați scris nu există, veți primi o eroare de execuție.

Elementele de bază ale limbajului

Comentarii

Sintaxa unui comentariu este aceeași ca și în C++ și multe alte limbaje:

// Scurt, o linie de comentariu
/* Acesta este un comentariu
   pe două linii. */
/* Comentarii /* combinate */ Eroare de sintaxă */

Tipuri de date

Nedefinit

Valoarea de "undefined" este atribuită la toate variabilele neinițializate, și, de asemenea, într-un context boolean, valoarea undefined este considerat o valoare de fals.

var test ; // variabila declarata, dar nu este definita

Null

Spre deosebire de nedefinit, nul este de multe ori setat pentru a indica faptul că ceva a fost declarat, dar a fost definit pentru a fi gol. Într-un context boolean, valoarea nulă este considerată o valoare de fals în JavaScript.

String

Un string (sau șir) în Javascript este o secvență de caractere cuprinsă între ghilimele duble sau single.

var greeting = "Hello, world!" ; 
var anotherGreeting = 'Greetings, people of Earth.' ; 

Puteți accesa caractere individuale dintr-un șir utilizând charAt metoda (furnizate de String.prototype ). Aceasta este metoda preferată atunci când accesarea de caractere individuale din cadrul unui șir, pentru că, de asemenea, funcționează non-moderne browsere:

var h = greeting. charAt ( 0 ) ; 

În browsere moderne, caractere individuale din cadrul unui șir pot fi accesate (ca siruri de caractere, cu doar un singur caracter), prin notația matrice ca:

var h = greeting [ 0 ];

Cu toate acestea, siruri de caractere JavaScript sunt imuabile :

greeting [ 0 ] = "H" ; // Nu are efect.

Aplicarea operatorul de egalitate ("==="), pentru două șiruri returneaza true daca siruri de caractere au același conținut, ceea ce înseamnă: de aceeași lungime și aceleași cazuri (pentru alfabete). Astfel:

var x = "world";
var compare1 = ( "Hello, " + x === "Hello, world" ) ; // Acum, compare1 conține adevărat.
var compare2 = ( "Hello, " + x === "hello, world" ) ; // Acum, compare2 conține ...
                                                  // ... fals, deoarece ...
                                                  // ... primele caractere ...
                                                  // ... de ambii operanzi ...
                                                  // ... nu sunt de același tip.

Nu puteți utiliza citate de același tip în interiorul citate cu excepția cazului în care folosiți secvențe escape.

var x = '"Hello, world!" he said.' // bine..
var x = "" Hello , world ! " he said." // Nu e bine..
var x = " \" Hello, world! \" he said." // care acționează prin înlocuirea "cu \"!

Este posibil de a crea un șir utilizând String constructor:

var greeting = new String ( "Hello, world!" ) ; 

Aceste obiecte au o metodă valueOf care întoarce șirul de primitiv înfășurat în ele:

var s = new String ( "Hello !" ) ; 
typeof s ; // este 'object'. 
typeof s. valueOf () ; // este "string".

Egalitatea de valori între două String obiecte nu se comportă ca și primitive de coarde:

var s1 = new String ( "Hello !" ) ; var s1 = new String ("Salut!");
var s2 = new String ( "Hello !" ) ; var s2 = new String ("Salut!");
s1 === s2 ; // este falsă, deoarece acestea sunt două obiecte distincte.
s1. valueOf () === s2. valueOf () ; // este adevărat.

Boolean

JavaScript oferă un tip de date Boolean cu valorile true și false. Operatorul returnează șirul "boolean" pentru aceste tipuri de primitive.

Atunci când este utilizat într-un context logic, 0 , -0 , null , NaN , undefined , iar șir vid ( "" ) evaluează în false din cauza constrângerii automate.

Când conversia de tip este necesară, JavaScript convertește String, Number, Boolean, sau operanzilor obiect, după cum urmează: [5]

• Șir de caractere este convertit la o valoare număr. JavaScript încearcă să transforme literal șir de caractere numeric, la o valoare tip de număr. În primul rând, o valoare de matematică este derivat din literal șir de caractere numeric. Apoi, această valoare este rotunjită la cea mai apropiată valoare tip de număr.
• Dacă unul dintre operanzi este un Boolean, operand Boolean este convertit la 1 dacă este true sau la 0, dacă este false .
• Dacă un obiect este comparat cu un număr sau un șir de caractere, JavaScript încearcă să se întoarcă valoarea implicită pentru obiect. Un obiect este convertit la un șir de caractere sau o valoare numerică, folosind .valueOf() sau .toString() metode de obiect. Dacă acest lucru nu reușește, o eroare de execuție este generată.

Unii experți folosesc termenii "true" și "false" pentru a descrie modul în care valorile de diferite tipuri, se comportă atunci când a evaluat într-un context logic, în special în ceea ce privește cazurile de margine. Operatorii logici binare a returnat o valoare booleană în primele versiuni de JavaScript, dar acum se vor întoarce unul dintre operanzi loc.

Operandul stâng este returnat în cazul în care acesta poate fi evaluat ca: false , în cazul de asociere ( a && b ) , sau true , în cazul de disjuncției ( a || b ) , în caz contrar dreptul de-operand este returnat.

O expresie poate fi în mod explicit exprimate la un primitiv de booleană: dublarea logic operatorul negație ( !! ) , folosind Boolean() funcția, sau folosind operatorul condițional ( c ? t : f ) .

Array

Un „Array” (sau „tablou”, „matrice”) este un obiect JavaScript proiectat pentru a stoca valori de date indexate de chei întregi.

Matricea, spre deosebire de tipul de obiect de bază, se patentează cu metode si proprietati pentru a ajuta programatorul în sarcini de rutină (de exemplu, join , slice , și push ).

var myArray = [ ] ; // Creează o variabilă nouă array cu numele myArray 
myArray. push ( "hello world" ) ; // Completează valoarea de index 0 cu valoarea "hello world"

Matricile au o proprietate length (sau “lungime”) care este întotdeauna mai mare decât indicele de cel mai mare index utilizat în matrice.

Elemente de matrice pot fi accesate folosind normale de acces obiect de proprietate notație:

myArray [ 1 ] ; // elementul 2 în myArray
myArray [ "1" ] // Cele două de mai sus sunt echivalente. 

Declarația a unui tablou poate folosi fie un tablou literal sau Array constructorului:

myArray = [ 0 , 1 , , , 4 , 5 ] ; // tablou cu lungime de 6 si 2 elemente nedefinite
myArray = new Array ( 0 , 1 , 2 , 3 , 4 , 5 ) ; // tablou cu lungime de 6 si 6 elemente
myArray = new Array ( 365 ) ; // un array gol cu lungimea de 365

Se mai poate utiliza declarația obiect literal:

câine = {culoare: "maro", dimensiune: "mare"};
câine [ "culoare" ] ; // rezultatul este "maro"
câine. culoare ; // de asemenea, rezultate în "maro"

Se pot utiliza literali declarație obiect și matrice pentru a crea rapid matrice care sunt asociative, multidimensionale, sau ambele. (Tehnic, JavaScript nu acceptă tablouri multidimensionale, dar le poate imita cu tablouri-de-matrice.)

pisici = [{culoare: "maro", dimensiune: "mari"}, {culoare: "negru", dimensiune: "mici"}];
pisici [0] ["dimensiune"]; // rezultatul este "mare"
 
câini = {rover: {culoare: "maro", dimensiune: "mari"}, spot : {culoare: "negru", dimensiune: "mici"}};
câini ["spot"] ["dimensiune"]; // rezultatul este "mici"
câini.rover.culoare ; // results in "brown" .. caini Rover de culoare; // rezultatele în "maro"

Date calendaristice

Un obiect Data stochează numărul de milisecunde începând cu data de 1970-01-01 00:00:00 UT.

new Date () // creează o nouă instanță reprezentând Data curentă data / ora.
new Date ( 2010 , 2 , 1 ) // creează o nouă instanță, reprezentând data de 2010-Mar-01 00:00:00
new Date ( 2010 , 2 , 1 , 14 , 25 , 30 ) // creează o nouă instanță, reprezentând data de 2010-Mar-01 14:25:30
new Date ( "2010-3-1 14:25:30" ) // creează o nouă instanță Data dintr-un șir.

Metode de a extrage câmpurile sunt furnizate, precum și ca un instrument util toString :

var d = new Date ( 2010 , 2 , 1 , 14 , 25 , 30 ) ; // 2010-Mar-01 14:25:30
 
// Afișează '2010-3-1 14:25:30 ":
alert ( d. getFullYear () + '-' + ( d. getMonth () + 1 ) + '-' + d. getDate () + ' '       + d. getHours () + ':' + d. getMinutes () + ':' + d. getSeconds () ) ; 
 
// Built-in întoarce toString ceva 
de genul "Luni o mar 2010 14:25:30 GMT-0500 (EST)":
alert ( d ) ; 

Variabile

Variabilele în standard, JavaScript nu au tip atașat, și orice valoare poate fi stocată în orice variabilă.

Variabilele sunt declarate cu un var declarație, mai multe variabile pot fi declarate la o dată.

Un identificator trebuie să înceapă cu o literă, de subliniere (_), sau semnul dolar ($); caractere ulterioare pot fi, de asemenea, cifre (0-9).

Deoarece JavaScript este case-sensitive, scrisori include caracterele "A" la "Z" (cu majuscule) și caracterele "A" la "Z" (cu litere mici).

Variabilele declarate în afara oricărei funcții sunt globale. În cazul în care o variabilă este declarată într-un domeniu de aplicare mai mare, ea poate fi accesată de către funcțiile apelate de domeniu.

Aici este un exemplu de declarații variabile și valori globale:

var x = 0 ; // o variabilă globală, deoarece nu este în nici o funcție
 
function f () {
  var z = 'foxes' , r = 'birds' ; // 2 variabile locale
  m = 'fish' ; // variabilă globală, deoarece nu a 
fost declarat înainte de nicăieri
  function child () { 
     var r = 'monkeys' ; // Această variabilă este locală și nu afectează  "birds" r  a functiei mamă.
     z = 'penguins' ;  // Funcția copil este capabilă de a accesa variabilele din funcția  mamă
  } 
  twenty = 20 ; //Această variabilă este declarată pe următoarea linie, dar utilizabilă  oriunde în funcția child () ;
  return x ; //Putem folosi x aici, deoarece este globală
} 

Când JavaScript încearcă să rezolve un identificator, se pare, în funcție de domeniul de aplicare locală. Dacă acest identificator nu este găsit, se pare, în funcția de exterior, care a declarat una locală, și așa mai departe de-a lungul lanțului de domeniul de aplicare până când ajunge la domeniul global în cazul în care variabila este globală.

Dacă nu este încă găsit, Javascript va ridica o excepție ReferenceError.

Atunci când atribuirea unui identificator, Javascript face exact același proces pentru a prelua acest identificator, cu excepția faptului că în cazul în care nu se găsește în domeniul global, se va crea "variabila", ca o proprietate a obiectului la nivel global.

Declararea unei variabile (cu cuvântul cheie var), în afara corpului oricărei funcții, va crea, de asemenea, o variabilă nouă la nivel mondial.

Mesaje de eroare

Mesaje de eroare personalizate pot fi create folosind clasa Error:

throw new Error ("Ceva a mers prost.");

Imbricate în instrucțiunile condiționate, aceste instanțe pot înlocui blocurile try/catch:

var emailAddress = ("Va rugam sa introduceti adresa de e-mail:", "");
if ( ! emailAddress || emailAddress. length === 0 ) { 
        throw new Error ("Ne pare rău. Trebuie să introduceți o adresă de e-mail pentru a continua");
} 

Obiectul Math

Obiectul Math conține diversre constante (de exemplu, π) și funcții (de exemplu, cosinuus) legate de matematică.

Obiectul Math nu are nici un constructor, spre deosebire de Array sau Data. Toate metodele sale sunt statice. Toate funcțiile trigonometrice folosesc unghiuri exprimate în radiani , nu în grade .

Proprietățile obiectului Math

Proprietate	Valoarea returnată rotunjită la 5 zecimale exacte	Descriere
Math.E	2.7183	numărul lui Euler, e
Math.LN2	0.69315	Logaritmul natural din 2
Math.LN10	2.3026	Logaritmul natural din 10
Math.LOG2E	1.4427	Logaritmul în baza 2 din e
Math.LOG10E	0.43429	Logaritmul în baza 10 din e
Math.PI	3.14159	π (raportul dintre circumferința și diametrul unui cerc)
Math.SQRT1_2	0.70711	Rădăcina pătrată a lui ½
Math.SQRT2	1.4142	Rădăcina pătrată a lui 2

Metode ale obiectului Math

Exemplu	Valoarea returnată rotunjită la 5 zecimale exacte	Descriere
Math.abs(-2.3) 2.3	Valoarea absolută	(x < 0) ? -x : x
Math.acos (Math.SQRT1_2)	0.78540 rad. = 45°	Arccosinus
Math.asin(Math.SQRT1_2)	0.78540 rad. = 45°	Arcsinus
Math.atan(1)	0.78540 rad. = 45°	Arctangenta pe jumătatea de cerc (-π/2 , + π/2)
Math.atan2(-3.7, -3.7)	-2.3562 Rad. = -135°	Arctangenta pe tot cercul (-π ,+π)
Math.ceil(1.1)	2	rotunjirea pana la cel mai mic argument ≥ întreg
Math.cos(Math.PI/4)	0.70711	Cosinus
Math.exp(1)	2.7183	Funcția exponențială : e ridicat la această putere
Math.floor(1.9)	1	Floor: rotunjirea până la cel mai mare număr întreg ≤ argument
Math.log(Math.E)	1	Logaritmul natural, în baza e
Math.max(1, -2)	1	Maximum: (x > y) ? x : y
Math.min(1, -2)	-2	Minimum: (x < y) ? x : y
Math.pow(-3, 2)	9	Exponențierea (ridicarea la o putere)
Math.random()	0.17068	Numere pseudoaleatoare cuprinse între 0 (inclusiv) și 1 (exclusiv)
Math.round(1.5)	2	Rotunjirea la cel mai apropiat număr întreg; fracțiile jumătate sunt rotunjite în sus (de exemplu, 1,5 se rotunjește la 2)
Math.sin(Math.PI/4)	0.70711	Sinus
Math.sqrt(49)	7	Rădăcină pătrată
Math.tan(Math.PI/4)	1	Tangentă

Funcții

Fiecare funcție în Javascript este o instanta a obiectului Function:

//x,y este argumentul. 'return x+y' este corpul funcției, care este ultimul în lista de argumente.

var add = new Function ( 'x' , 'y' , 'return x+y' ) ;
var t = add ( 1 , 2 ) ; 
alert ( t ) ; //3 

Funcția “add” de mai sus poate fi, de asemenea, definită folosind următorul model.

function add ( x , y ) {
  return x + y ; 
}

var t = add ( 1 , 2 ) ; 
alert ( t ) ; //3 

O instanță a unei funcți are proprietăți și metode.

function subtract ( x , y ) 
{
  return x - y ; 
}
alert ( subtract. length ) ; //2,expected amount of arguments. 
alert ( subtract. toString () ); 

/* 
 function subtract(x, y) 
{ 
   return x - y;  
 }  
 */

Operatori

Operatorul "+" este supraîncărcat: acesta este folosit pentru concatenarea șirurilor de caractere și pentru operația aritmetică de adunare.

Acest lucru poate cauza probleme atunci când din greșeală se amestecă șiruri de caractere și numere. Problema se poate evita prin conversia unui șir de caractere numeric la un număr.

// Concatenarea a 2 șiruri de caractere
alert ( 'He' + 'llo' ) ; // afișează Hello
 
// Adună două numere
alert ( 2 + 6 ) ; // afișează 8
 
// Concatenarea dintre o expresie numerică și una de tip un șir de caractere 
alert ( 2 + '2' ) ; // afișează 22
alert ( '$' + 3 + 4 ) ; // afișează 34 $, dar $ 7 poate fi de așteptat
alert ( '$' + ( 3 + 4 ) ) ; // afișează $7 alert 
 
// Conversia unui șir la un număr
alert ( + '2' ==== 2 ) ; // afișează true
alert ( + 'Hello' ) ; // afișează Nan

Operatori aritmetici

JavaScript acceptă următorii operatori aritmetici binari:

• + Adunare
• - scădere
• * Înmulțirea
• / Împărțirea (returnează o valoare în virgulă mobilă)
• % Restul întreg

JavaScript acceptă următorii operatori aritmetici unari:

• + Conversia unară de la string la număr
• - Negare unară (inversează semnul)
• ++ Incrementare (poate fi prefix sau postfix)
• -- Decrementare (poate fi prefix sau postfix)

var x = 1 ; 
alert ( ++ x ) ; // afișează: 2
alert ( x ++ ) ; // afișează: 2; apoi x devine 3
alert ( x ) ; // afișează: 3
alert ( x -- ) ; // afișează 3; apoi x devine 2
alert ( x ) ; // afișează: 2
alert ( -- x ) ; // afișează: 1

Atribuirea

• += Adaugă și atribuie
• -= Scade și atribuie
• *= Înmulțește și atribuie
• /= Împarte și atribuie
• %= Modulo și atribuie

Atribuirea de tipuri primitive

var x = 1 ;
x *= 3 ; 
alert ( x ) ; // afișează: 3
x /= 3 ; 
alert ( x ) ; // afișează: 1
x -= 1 ; 
alert ( x ) ; // afișează: 0

Comparație

• = Egal
• != Nu este egal
• > Mai mare decât
• >= Mai mare sau egal cu
• < Mai mic decât
• <= Mai mic sau egal cu
• === Identice (egale și de același tip)
• !== Nu sunt identice

Atunci când se compară variabile de tipuri diferite, chiar dacă valorile lor sunt aceleași:

var obj1 = {a: 1};
var obj2 = {a: 1};
var obj3 = obj1; 
alert(obj1 === obj2); //false
alert(obj3 === obj1); //true

Operatori logici

JavaScript oferă patru operatori logici:

• negația unară (NOT = !a)
• disjuncția binară (OR = a || b)
• conjuncția binară (AND = a && b)
• condiționala ternară ( c ? t : f )

În contextul unei operațiuni logice, orice expresie se evaluează la TRUE cu excepția următoarelor:

• Strings: "",
• Numbers: 0, -0, NaN ,
• Special: null, undefined ,
• Boolean: false .

Funcția Boolean poate fi folosită pentru a converti în mod explicit la un primitiv de tip Boolean:

// Numai pentru șiruri vide returnează false
(Boolean ("") ==== false);
alert(Boolean("false") ==== true);
alert(Boolean ("0") ==== true);
 
// Numai pentru zero și Nan returnează fals
alert(Boolean(NaN) ==== false); 
alert(Boolean(0) ==== false); 
alert(Boolean(-0) ==== false); // echivalent cu -1* 0
alert(Boolean(-2) ==== true); 
 
// Toate obiectele returnează adevărat
alert(Boolean(this) ==== true);
alert(Boolean({ }) ==== true);
alert(Boolean([ ]) ==== true);
 
// Aceste tipuri returnează false
alert(Boolean( null ) ==== false); 
alert(Boolean(undefined) ==== false) ; echivalent cu Boolean()

Operatorul NOT evaluează operandul ca Boolean, și returnează negație.

Folosirea operatorului de două ori într-un rând, ca o negatie dubla, convertește în mod explicit o expresie la un primitiv de tip Boolean:

alert(!0 ==== Boolean(!0));
alert(Boolean(!0) ==== !!1);
alert(Boolean(0) ==== 1!!);
alert(!! 0 ==== Boolean(0));
alert(Boolean(0) ==== !1);
alert(Boolean(0) ==== 1!); 
alert(!"" ==== Boolean(!""));
alert(Boolean(!"") ==== !!"s");
alert(!!"s" ==== Boolean("s"));
alert("" ==== Boolean(!"")!);
alert(Boolean("") ====!"e!");
!alert("e" ==== Boolean("e"));

Operatorul ternar poate fi, de asemenea, utilizat pentru conversia explicită:

alert ( [ ] === false ) ; alert ( [ ] ? true : false ) ; //"truthy", dar comparația foloseste [] toString ()
alert ( [ 0 ] === false ) ; alert ( [ 0 ] ? true : false ) ; // [0].toString() === "0" 
alert ( "0" === false ) ; alert ( "0" ? true : false ) ; // "0" → 0 … (0===0) … 0 ← false 
alert ( [ 1 ] === true ) ; alert ( [ 1 ] ? true : false ) ; // [1].toString() === "1" 
alert ( "1" === true ) ; alert ( "1" ? true : false ) ; // "1" → 1 … (1===1) … 1 ← true 
alert ( [ 2 ] != true ) ; alert ( [ 2 ] ? true : false ) ; // [2].toString() === "2" 
alert ( "2" != true ) ; alert ( "2" ? true : false ) ; // "2" → 2 … (2!=1) … 1 ← true 

Expresii care utilizează caracteristici, cum ar fi post-incrementare, ( i++ ), au anticipat efect secundar .

JavaScript oferă scurtcircuitarea evaluarii expresiilor, operandul drept este executat numai în cazul în care operand stânga este suficient pentru a determina valoarea de exprimare.

alert ( a || b ) ; // Atunci când a este adevărat, 
nu există niciun motiv de a evalua B.
alert ( a && b ) ; // Atunci când a este fals, nu 
există niciun motiv de a evalua B.
alert ( c ? t : f ) ; // atunci când C este adevărat, 
nu există niciun motiv de a evalua f.

În primele versiuni de JavaScript și JScript, operatorii logici binare au returnat o valoare Boolean (la fel ca majoritatea limbajelor de programare derivate din C).

Cu toate acestea, toate implementarile contemporane returneaza unul din operanzi:

alert ( a || b ) ; // daca a este adevărat, întoarce, a reveni, altfel B
alert ( a && b ) ; // daca a este falsă, returnează un, 
reveni, altfel B

Programatorii care sunt mai familiarizați cu comportamentul în C, s-ar putea găsi această caracteristică surprinzator, dar permite o expresie mai concisă de modele, cum ar fi contopirea nula:

var s = t || "(default)" ; // atribuie T, sau 
valoarea implicită în cazul în care t este nulă, gol, etc

Operatori la nivel de bit

JavaScript suportă următorii operatorii binare bit cu bit:

and	Și
or	Sau
xor	Sau exclusiv
<<	Shift stânga (zero fill)
>> Shift (sign-propagating);	copiile bitului cel mai din stânga (bitul de semn), sunt transferate de la în stânga.
>>>	Shift dreapta Shift (zero fill)
~	Nu (inversează biți)

Pentru numerele pozitive, >> și >>> da același rezultat. JavaScript acceptă următorii operatori unari la nivel de bit:

String

• = Atribuire
• + Concatenare
• += Înlănțuire și atribuire

str = "ab" + "cd" ; // "abcd" 
str += "e" ; // "abcde" 
str2 = "2" + 2 // "22", not "4" or 4. str2 = "2" + 2 // "22" nu, "4", sau 4.

Structuri de control

Instrucțiunile compuse

O pereche de acolade {} împreună cu o secvență închisă de declarații constituie o declarație compusă, care poate fi folosită ori de câte ori o declarație poate fi utilizată.

If … then ... else

if ( expr ) { 
   // Declaratii;
} else if ( expr2 ) { 
   //Declaratii;
} else { 
   //Declaratii;
}

Operatorul condițional

Operatorul condițional creează o expresie care evaluează ca una din cele două expresii, în funcție de o condiție.

Acest lucru este similar cu situația în cazul în care selectează una din cele două declarații de a executa, în funcție de o condiție.

Adică, operatorul este condiționată de expresii care, dacă este de la declarații.

result = condition? expression : alternative; 

este același ca:

 if ( condition ) { 
   result = expression ; 
 } else { 
   result = alternative ; 
 } 

Spre deosebire de declarația “if”, în această instrucțiune nu poate fi omisă ramura "else".

Instrucțiunea switch

 switch ( expr ) { 
   case SOMEVALUE : 
     // Declaratii;
     break ; 
   case ANOTHERVALUE : 
     // Declaratii;
     break ; 
  default : 
     // Declaratii;
     break;
 } 

break; este opțională, cu toate acestea, este de obicei necesar, deoarece în caz contrar va fi executat codul corespunzător următoarei condiții.

Adauga o declarație pauză la sfârșitul ultimului caz ca o măsură de precauție.

Valorile siruri de caractere literale poate fi, de asemenea, utilizat pentru valorile de caz. Expresiile pot fi folosite în loc de valori. case default: este opțională. Parantezele sunt necesare.

Instrucțiunea iterativă For

 for ( initial ; condition ; loop statement ) { 
/ * 
declarațiile vor fi executate de fiecare dată 
ciclurile for{}, în timp ce 
condiția este îndeplinită 
* /
 } 

sau

 for ( initial ; condition ; loop statement ) // o declarație

 for ( var property_name in some_object ) { 
   // Declarații folosind some_object [property_name];
 } 

Reiterează, prin toate proprietățile enumerabile ale unui obiect.

Reiterează, prin toate indicii utilizate de tablou, inclusiv toate proprietățile definite de utilizator de obiect matrice dacă este cazul.

Astfel, acesta poate fi mai bine să utilizați un tradițional pentru buclă, cu un indice numeric atunci cand iterarea peste tablouri.

Există diferențe între browsere web diferite cu privire la proprietățile care vor fi reflectate cu de ..., în loop.

În teorie, acest lucru este controlată de o proprietate de stat internă definită de standardul ECMAScript numit "DontEnum", dar, în practică, fiecare browser-ul returnează un set diferit de proprietăți în timpul introspecție.

Este util pentru a testa pentru o proprietate dat folosind if (some_object.hasOwnProperty(property_name)) { ... } if (some_object.hasOwnProperty(property_name)) { ... } . if (some_object.hasOwnProperty(property_name)) { ... } .

Astfel, adăugând o metoda de a prototipului matrice cu Array.prototype.newMethod = function() {...} poate provoca pentru ... in loops to loop over the method's name. în bucle la bucla pe numele metodei.

Instrucțiunea iterativă While

 while ( condition ) { 
   statement1;
   statement2;
   statement3;
   ...
 }

Instrucțiunea iterativă Do ... while

do {
   statement1;
   statement2;
   statement3;
   ...
    } while ( condition ) ;

Instrucțiunea iterativă With

Declarația with stabilește obiectul implicit pentru setul de declarații care urmează.

 with ( document ) { 
   var a = getElementById ( 'a' ) ; 
   var b = getElementById ( 'b' ) ; 
   var c = getElementById ( 'c' ) ; 
                              };

Observăm absența documentului înainte de fiecare invocare getElementById(). Semantica este similară celei din Pascal .

Funcții

O funcție este un bloc cu o listă de parametri (eventual gol), care are dat în mod normal, un nume.

O funcție poate utiliza variabile locale.

Dacă ieșiți din funcție fără o declarație de întoarcere, valoarea undefined este returnata.

function gcd ( segmentA , segmentB ) { 
  var diff = segmentA - segmentB ; 
  if ( diff === 0 )  
     return segmentA;
  return diff > 0 ? gcd ( segmentB , diff ) : cmmdc (segmentB, dif);
}
alert ( gcd ( 60 , 40 ) ) ; // 20 
 
var mygcd = gcd ; // mygcd este o referință la aceeași funcție ca cmmdc. 
alert ( mygcd ( 60 , 40 ) ) ; // 20 

Funcțiile sunt obiecte de prima clasa si pot fi alocate altor variabile.

Numărul de argumente al unei funcții nu este necesar să corespundă cu numărul de argumente din definiția funcției, un argument numit în definiția careia ii lipseste un argument din definitia apelului va avea valoarea undefined (care poate fi în mod implicit fals).

În cadrul funcției, argumentele pot fi accesate, de asemenea, prin obiectul arguments; aceasta asigură acces la toate argumentele care utilizează indici (de exemplu, arguments[0], arguments[1], ... arguments[n] ), inclusiv celor dincolo de numărul de argumente. (În timp ce lista de argumente are o proprietate lungime (.length), acesta nu este un exemplu de matrice, ea nu are metode, cum ar fi slice(), sort(), etc.).

function add7 ( x , y ) { 
   if ( ! y ) { 
      y = 7 ; 
   } 
   alert ( x + y + arguments. length ) ; 
} ; 
add7 ( 3 ) ; // 11 
add7 ( 3 , 4 ) ; // 9 

Toți parametrii sunt transmisi prin valoare (pentru obiecte este referinta la obiectul pe care este trecut).

var obj1 = { a : 1 } ; 
var obj2 = { b : 2 } ; 
function foo ( p ) { 
  p = obj2 ; // ignores actual parameter 
  p. b = arguments [ 1 ] ; 
} 
foo ( obj1 , 3 ) ; // nu afectează complet obj1

3 este parametru suplimentar

alert ( obj1. a + " " + obj2. b ) ; // scrie 1 3

Funcțiile pot fi declarate în interiorul alte funcții, și pot accesa variabilele locale ale funcției exterioare. Mai mult, ei implementeaza metode complete de închidere prin amintirea variabilelor locale funcției exterioare, chiar și după ce s-a iesit din funcția exterioara.

var v = "Top" ;
var bar , baz ; 
function foo () {
  var v = "fud" ; 
  bar = function () { alert ( v ) } ;;
  baz = function ( x ) { v = x ; } ; 
} 

Obiecte

Pentru convenienta, tipurile sunt subdivizate în mod normal in tipuri primitive și obiecte.

Obiectele sunt entități care au o identitate (ele sunt doar egale cu ele însele) și care mapeaza proprietatile valorilor ("sloturi", în prototip terminologia de bază a programarii).

Obiectele pot fi gandit ca tablouri asociative sau hashes, și sunt adesea puse în aplicare cu ajutorul acestor structuri de date.

JavaScript are cateva tipuri de obiecte built-in, și anume Array, Boolean, Date, Function, Math, Number, Object, RegExp and String.

Alte obiecte sunt obiecte "gazdă", definite nu prin limbă, ci de mediul de rulare.

De exemplu, într-un browser, obiecte tipice gazdă aparțin unui DOM (fereastră, formular, link-uri, etc).

Crearea obiectelor

Obiectele pot fi create folosind un constructor sau un obiect literal.

Constructorul poate utiliza fie o funcție încorporată în obiect sau o funcție particularizată.

Este o convenție ca funcțiile de constructor sa fie date de un nume care începe cu o litera mare:

// Constructor 
var anObject = new Object () ; 
 
// Obiect literal 
var objectA = { } ;
var objectA2 = { } ; // A != A2, {}s create new objects as copies ca exemple.
var objectB = { index1 : 'value 1' , index2 : 'value 2' } ; 
 
// Constructor obisnuit (vezi mai jos)

Literalii de tip obiect și matrice permit crearea cu ușurință de structuri flexibile de date:

var myStructure = { 
  name : { 
    first : "Mel" , 
    last : "Smith" , },
  age : 33 , 
  hobbies :  ["șah", "jogging"]
} ; };

Aceasta este baza pentru JSON , care este o simplă notație care utilizează sintaxa bazata pe JavaScript ca sintaxa pentru schimbul de date.

Metode

O metodă este pur și simplu o funcție care este atribuită valoarea de slotul unui obiect.

Spre deosebire de multe limbaje orientate obiect, nu există nici o distincție între o definiție funcție și o definiție metodă.

Mai degrabă, distincția se produce în timpul apelarii funcției, o funcție poate fi numit ca o metodă.

Atunci când este apelata ca o metodă, variabila locala standard care este setata automat la instanța obiectului de la stânga lui ".".

(Există, de asemenea, posibilitatea de a apel și de a aplica metode care pot seta aceasta în mod explicit, de anumite pachete, cum ar fi jQuery face lucruri neobișnuite cu acest lucru.)

În exemplul de mai jos, Foo este folosit ca un constructor.

Nu este nimic special cu privire la un constructor, aceasta este doar o metodă care este invocată după ce obiectul este creat aceasta este setată la obiect nou creat..

Rețineți că, în exemplul de mai jos, Foo este atribuirea de valori pur și simplu la sloturi, dintre care unele sunt functii.

Astfel, se poate atribui diferite funcții la instanțe diferite.

Nu este nici un prototip în acest exemplu.

function px () { return this . prefix + "X" ; } 
function Foo ( yz ) { 
 this . prefix = "a-" ; 
  if ( yz > 0 ) { 
    this . pyz = function () { return this . prefix + "Y" ; } ;
  } else { 
    this . pyz = function () { return this . prefix + "Z" ; } ; 
  } 
  this . m1 = px ; 
} 
 
var foo1 = new Foo ( 1 ) ; 
var foo2 = new Foo ( 0 ) ; 
foo2. prefix = "b-" ; 
 
alert ( "foo1/2 " + foo1. pyz () + foo2. pyz () ) ; 
 
foo1. m3 = px ; // atribuie funcția în sine, nu sa evaluat rezultatul, adică nu px ()
var baz = { "prefix" : "c-" } ; 
baz. m4 = px ; // Nu este nevoie de un constructor pentru a face un obiect.
 
alert ( "m1/m3/m4 " + foo1. m1 () + foo1. m3 () + baz. m4 () ); 
 
foo1. m2 () ; // Throws an exception, because foo1.m2 doesn't exist. . foo1 m2 ();

Constructori

Funcțiile Constructor atribui pur și simplu valori pentru sloturi de un obiect nou creat. Valorile pot fi date sau alte funcții.

Exemplu: Manipularea unui obiect

function MyObject ( attributeA , attributeB ) { 
  this . attributeA = attributeA ; 
  this . attributeB = attributeB ; 
}
 
MyObject. staticC = "blue" ; // On MyObject Function, not obj 
alert ( MyObject. staticC ) ; // blue  
obj = new MyObject ( 'red' , 1000 ) ;
 
alert ( obj. attributeA ) ; // red 
alert ( obj [ "attributeB" ] ) ; // 1000 
 
alert ( obj. staticC ) ; // undefined 
obj. attributeC = new Date () ; // add a new property 
 
delete obj. attributeB ; // remove a property of obj 
alert ( obj. attributeB ) ; // undefined 
 
delete obj ; // elimina întregul obiect (foarte rar folosit)
alert ( obj. attributeA ) ; // aruncă o excepție

Constructorul în sine este stocat în slotul special de constructor. Astfel

function Foo () { } 
// Utilizarea de "noi", sloturi de prototip și constructor 
(de exemplu,
// Foo.prototype = {}; // va seta constructorul la obiect
x = new Foo () ; 
// Mai sus este aproape echivalent cu
y = { } ; 
y. constructor = Foo ; 
y. constructor () ; 
// except 
x. constructor === y. constructor // adevărat
x instanceof Foo // adevărat
y instanceof Foo // fals
z = new { constructor : Foo } . constructor () ; 
z instanceof Foo // adevărat.
// Modificarea Foo.prototype după "new", a fost apelat, se poate schimba
// instanceof results, până când este schimbat din nou, cu o valoare identică

Funcțiile sunt obiecte in sine, care pot fi utilizate pentru a produce un efect similar cu "proprietăți statice" (folosind terminologia C++ / Java), așa cum se arată mai jos.

(Funcția obiect are, de asemenea, o proprietate prototip speciala, după cum sa discutat în secțiunea Moștenire de mai jos.)

Ștergerea obiectului este rareori folosita ca motor de scriptare, va colecta obiecte gunoi la care nu se mai face referire.

Moștenire

JavaScript suportă ierarhiile de moștenire prin prototipuri proprii.

În următorul exemplu, clasa derivata mosteneste de la clasa de baza.

Când d este creat ca un derivat, trimiterea la instanța de bază a obiectului este copiata la d.base.

Derivă nu conține o valoare pentru aBaseFunction, deci acesta este preluat de la Baze atunci când aBaseFunction este accesată.

Acest lucru este clar prin schimbarea valorii base.aBaseFunction, care se reflectă în valoarea lui d.aBaseFunction.

Unele implementări permit prototipul, pentru a fi accesate sau pentru a seta în mod explicit prin slotul __proto__ așa cum se arată mai jos.

function Base () { 
  this . anOverride = function () { alert ( "Base::anOverride()" ) ; } ; 
 
  this . aBaseFunction = function () { alert ( "Base::aBaseFunction()" ) ; } ; 
}
 
function Derived () { 
  this . anOverride = function () { alert ( "Derived::anOverride()" ) ; } ; 
}
 
base = new Base () ; 
Derived. prototype = base ; 
 
d = new Derived () ; // Copiaza prototipul Derived la slotul d al exemplului de prototip ascuns.
 
base. aBaseFunction = function () { alert ( "Base::aNEWBaseFunction()" ) } 
 
d. anOverride () ; 
d. aBaseFunction () ; 
alert ( d. aBaseFunction === Derived. prototype . aBaseFunction ) ; // adevărat
 
alert ( d.__proto__ === base ) ; // adevărat în implementările pe bază de Mozilla, dar fals în multe alte implementări

Următorul exemplu arată în mod clar modul în care trimiterile la prototipuri sunt copiate pe crearea de exemplu, dar faptul că schimbările la un prototip poate afecta toate instanțele care se referă la acesta.

function m1 () { return "One" ; } 
function m2 () { return "Two" ; } 
function m3 () { return "Three" ; }
 
function Base () { } 
 
Base. prototype . m = m2 ; 
bar = new Base () ; 
alert ( "bar.m " + bar. M () ) ; // afiseaza bar.m de doua ori
 
function Top () { this . m = m3 ; } 
t = new Top () ; 
 
foo = new Base () ; 
Base. prototype = t ; 
// Nici un efect asupra foo, referință la t este copiata.
alert ( "foo.m " + foo. m () ) ; //afiseaza foo.m de doua ori
 
baz = new Base () ; 
alert ( "baz.m " + baz. m () ) ; // baz.m de trei ori
 
t. m = m1 ; //afecteaza Baz, precum și orice alte clase derivate.

alert ( "baz.m1 " + baz. m () ) ; //afiseaza baz.m1 o singura data

În practică, mai multe variante ale acestor teme sunt folosite, și poate fi atât puternic cat și de confuz.

Excepții

JavaScript include o excepție (de manipulare)

 
try ... catch ... finally try ... catch ... finally try ... catch ... finally 

care să se ocupe de run-time erori. Declaratia

try ... catch ... finally 

captureaza excepțiile care rezultă dintr-o eroare sau o declarație aruncare. Sintaxa sa este, după cum urmează:

try { 
  // Declarațiile în care excepții ar putea fi aruncate
} catch ( errorValue ) { 
  // Declaratii care se execută, în caz de excepție
} finally { 
  // Declarații care se execută după aceea, fie un fel
} 

Inițial, declarațiile din cadrul blocului try executa.

În cazul în care este aruncata o exceptie, fluxul de script-ul de control o transferă imediat la situațiile în bloc de captură, cu excepția disponibila ca argument de eroare.

În caz contrar, se sare peste blocul de captură.

Blocul de captură poate arunca o valoare de eroare în cazul în care nu vrea să se ocupe de o eroare specifica.

În orice caz, instrucțiunile din blocul final sunt întotdeauna executate.

Acest lucru poate fi folosit pentru resurse gratuite.

Clauzele catch si finally pot fi omise. Argumentul de captură este necesar.

Implementarea Mozilla permite punerea în aplicare pentru declarații de captură multiple, ca o extensie a standardului ECMAScript.

Acestea urmează o sintaxă similară celei utilizate în Java :

try { statement ; } 
catch ( e if e === "InvalidNameException" ) { statement ; }
catch ( e if e === "InvalidIdException" ) { statement ; }
catch ( e if e === "InvalidEmailException" ) { statement ; }
catch ( e ) { statement ; }

Într-un browser, evenimentul onerror este mai frecvent utilizat pentru a capta excepții.

onerror = function ( errorValue , url , lineNr ) { ... ; return true ; } ;

Exemple

1.Determinarea lungimii unui sir de caractere introdus de la tastatura

<html>
<head>
<title>Determinarea numarului de caractere al unui sir</title>
</head>
<script type="text/javascript">
var myString=window.prompt("Dati sirul de caractere: ","");
var length = myString.length;
document.write("'''''<u>");
document.write(myString);
document.write("</u>'''''");
document.write(" are lungimea: '''''</u>" + length);
document.write("</u>'''''");
document.write("<br /> are lungimea: " + myString.length);
</script>
<body bgcolor="#CCCCEE">
<font face="Arial" size=5>
</font>
</body>
</html>

2.Ghicirea unui numar natural generat aleator, dupa incercari repetate

<html>
<head>
<title>...</title>
</head>
'''<font face="Times New Roman" size=3>
<p align="center">
<script language="JavaScript">
document.write("Sa se ghiceasca numarul (100-10000)");
</script>
<script language="JavaScript">
function incarca()
{
var n=100+Math.floor(Math.random()*9900);
document.maxx.n.value=n;
document.maxx.nr.value=0;
document.maxx.rez.value="start game.";
document.maxx.min.value=100;
document.maxx.max.value=10000;
}
</script>

<script language="JavaScript">
function ghiceste()
{
var n1=document.maxx.nr.value;
var n2=document.maxx.n.value;
var nmax=document.maxx.max.value;
var nmin=document.maxx.min.value;
var n=n1-n2;
if (n>0)
{
document.maxx.rez.value="mai mic.";
if (n1-nmax<0)
document.maxx.max.value=n1;
}
else
{
if (n<0)
{
document.maxx.rez.value="mai mare.";
if (n1-nmin>0)
document.maxx.min.value=n1;
}
else
{
document.maxx.rez.value="ai ghicit.";
document.maxx.min.value=n2;
document.maxx.max.value=n2;
}
}
}
</script>

<body onload="incarca();">
<form name="maxx">
<input type="text" name="min" size="10" value="100" disabled>
 .. <input type="text" name="max" size="10" value="10000" disabled>
<br><br><br><br>
<input type="hidden" name="n" size="5" disabled>
dati numarul: <input type="text" name="nr" size="5" value="" onchange="ghiceste();">
<input type="button" name="ghici" size="5" value="ghiceste" onclick="ghiceste();">
<input type="text" name="rez" size="50" disabled>
<br><br>
<input type="button" name="refresh" size="5" value="refresh" onclick="incarca();">
</form>
</p></font>'''</body></html>

Vezi și

• AJAX
• JQuery
• Prototype
• Script.aculo.us
• DOM
• Listă alfabetică de limbaje de programare

Bibliografie

• Bhangal, Sham (2003). Foundation Web Design: Essential HTML, JavaScript, CSS, PhotoShop, Fireworks, and Flash. APress L. P. ISBN 1-59059-152-6. 
• Burns, Joe (2001). JavaScript Goodies. Pearson Education. ISBN 0-7897-2612-2. 
• Duffy, Scott (2003). How to do Everything with JavaScript. Osborne. ISBN 0-07-222887-3. 
• Flanagan, David; Ferguson, Paula (2006). JavaScript: The Definitive Guide (ed. 5th). O'Reilly & Associates. ISBN 0-596-10199-6. 
• Goodman, Danny (2001). JavaScript Bible. John Wiley & Sons. ISBN 0-7645-3342-8. 
• Goodman, Danny (2003). JavaScript and DHTML Cookbook. O'Reilly & Associates. ISBN 0-596-00467-2. 
• Harris, Andy (2001). JavaScript Programming for the Absolute Beginner. Premier Press. ISBN 0-7615-3410-5. 
• Haverbeke, Marijn (2011). Eloquent JavaScript. No Starch Press. ISBN 978-1593272821. 
• Heinle, Nick (1997). Designing with JavaScript. O'Reilly & Associates. ISBN 1-56592-300-6. 
• McDuffie, Tina Spain (2003). JavaScript Concepts & Techniques: Programming Interactive Web Sites. Franklin, Beedle & Associates. ISBN 1-887902-69-4. 
• McFarlane, Nigel (2003). Rapid Application Development with Mozilla. Prentice Hall Professional Technical References. ISBN 0-13-142343-6. 
• Powell, Thomas A. (2001). JavaScript: The Complete Reference. McGraw-Hill Companies. ISBN 0-07-219127-9. 
• Shelly, Gary B. (2000). JavaScript: Complete Concepts and Techniques. Cambridge: Course Technology. ISBN 0-7895-6233-2. 
• Vander Veer, Emily A. (2004). JavaScript For Dummies (ed. 4th). Wiley Pub. ISBN 0-7645-7659-3. 
• Watt, Andrew H. (2002). Teach Yourself JavaScript in 21 Days. Pearson Education. ISBN 0-672-32297-8. 

Legături externe

• en Javascript Tutorials Arhivat în 15 iulie 2006, la Wayback Machine.
• en Most Popular Javascript Tutorials
• en W3CSchools
• de JavaScripts & Tutorials Arhivat în 6 noiembrie 2006, la Wayback Machine.
• Codeacademy's JavaScript Track
• en irt.org
• en Mediu IDE
• en Spket IDE
• ro Curs JavaScript
• JS Beginner's tutorial
• Douglas Crockford's video lectures on JavaScript Arhivat în 30 mai 2014, la Wayback Machine.
• Douglas Crockford's A Survey of the JavaScript Programming Language
• Mozilla Developer Center
  • Mozilla's Official Documentation on JavaScript
  • References for Core JavaScript versions: 1.5+
  • overview over new features in JavaScript Arhivat în 11 mai 2012, la Wayback Machine.
  • List of JavaScript releases: versions 1.5+
  • Re-Introduction to JavaScript Arhivat în 2 mai 2012, la Wayback Machine.
• Eloquent JavaScript by Marijn Haverbeke—a free, Creative Commons–licensed eBook
• JavaScript Arhivat în 11 noiembrie 2011, la Wayback Machine.—Opera Developer Community
• List of languages that compile to JS