JavaScript - Wikipedia

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ă
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
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.
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.
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 ) .
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"
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 ) ;
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 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 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 .
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)
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)
Floor: rotunjirea până la cel mai mare număr întreg ≤ argument
Math.log(Math.E)
Logaritmul natural, în baza e
Math.max(1, -2)
Maximum: (x > y)
? x
: y
Math.min(1, -2)
-2
Minimum: (x < y)
? x
: y
Math.pow(-3, 2)
Exponențierea (ridicarea la o putere)
Math.random()
0.17068
Numere pseudoaleatoare cuprinse între 0 (inclusiv) și 1 (exclusiv)
Math.round(1.5)
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)
Rădăcină pătrată
Math.tan(Math.PI/4)
Tangentă
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;
*/
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
// afișează 8
// Concatenarea dintre o expresie numerică și una de tip un șir de caractere
alert
'2'
// afișează 22
alert
'$'
// afișează 34 $, dar $ 7 poate fi de așteptat
alert
'$'
// afișează $7 alert
// Conversia unui șir la un număr
alert
'2'
====
// afișează true
alert
'Hello'
// afișează Nan
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
alert
++
// afișează: 2
alert
++
// afișează: 2; apoi x devine 3
alert
// afișează: 3
alert
--
// afișează 3; apoi x devine 2
alert
// afișează: 2
alert
--
// afișează: 1
+=
Adaugă și atribuie
-=
Scade și atribuie
*=
Înmulțește și atribuie
/=
Împarte și atribuie
%=
Modulo și atribuie
var
*=
alert
// afișează: 3
/=
alert
// afișează: 1
-=
alert
// afișează: 0
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
};
var
obj2
};
var
obj3
obj1
alert
obj1
===
obj2
);
//false
alert
obj3
===
obj1
);
//true
JavaScript oferă patru operatori logici:
negația unară (NOT =
disjuncția binară (OR =
||
conjuncția binară (AND =
&&
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
====
false
);
alert
Boolean
====
false
);
// echivalent cu -1* 0
alert
Boolean
====
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
====
Boolean
));
alert
Boolean
====
!!
);
alert
Boolean
====
!!
);
alert
!!
====
Boolean
));
alert
Boolean
====
);
alert
Boolean
====
);
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
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:
= 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.
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
expr
// Declaratii;
else
if
expr2
//Declaratii;
else
//Declaratii;
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".
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.
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.
while ( condition ) {
statement1;
statement2;
statement3;
...
do {
statement1;
statement2;
statement3;
...
} while ( condition ) ;
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 .
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

// 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.
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 ();
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.
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.
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 ; } ;
1.Determinarea lungimii unui sir de caractere introdus de la tastatura

Determinarea numarului de caractere al unui sir

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

...

'''

'''