Meniu
AcasăPrograme

Cum se apelează funcții în js. Ieșirea funcției și rezultatul acesteia. Supraîncărcarea funcției în JavaScript

Funcții

O funcție este un bloc codul programuluiîn JavaScript, care este definit o dată și poate fi executat sau apelat în mod repetat. Este posibil să fiți deja familiarizați cu conceptul de funcție sub alt nume, cum ar fi o subrutină sau o procedură. Funcțiile pot avea parametri: o definiție de funcție poate include o listă de identificatori, care sunt numiți parametri și acționează ca variabile locale în corpul funcției.

La apelarea funcțiilor, acestora li se pot transmite valori sau argumente corespunzătoare parametrilor lor. Funcțiile își folosesc adesea argumentele pentru a calcula o valoare returnată, care este valoarea expresiei de apelare a funcției. Pe lângă argumente, atunci când orice funcție este apelată, i se mai trece o valoare care definește contextul apelului - valoarea din cuvântul cheie this.

Funcțiile din JavaScript sunt obiecte și pot fi utilizate în moduri diferite. De exemplu, funcțiile pot fi atribuite variabilelor și transmise altor funcții. Deoarece funcțiile sunt obiecte, puteți atribui valori proprietăților lor și chiar le puteți apela metode.

JavaScript permite definițiile de funcții să fie imbricate în alte funcții, iar astfel de funcții vor avea acces la toate variabilele prezente în domeniul de aplicare al definiției.

Definirea Funcțiilor

O definiție a funcției începe cu cuvântul cheie function, urmat de următoarele componente:

Un identificator care specifică numele funcției

Numele este o parte obligatorie a instrucțiunii de declarare a funcției: va fi folosit pentru a crea o nouă variabilă căreia îi va fi atribuit obiectul caracteristică nouă. În expresiile de definire a funcției, numele poate fi absent: dacă este prezent, numele se va referi la obiectul funcție doar în corpul funcției în sine.

Pereche parantezeleîn jurul unei liste de zero sau mai mulți identificatori, despărțiți prin virgule

Acești identificatori vor defini numele parametrilor funcției și pot fi utilizați ca variabile locale în corpul funcției.

O pereche de bretele cu zero sau mai multe instrucțiuni JavaScript în interior

Aceste instrucțiuni alcătuiesc corpul funcției: ele sunt executate de fiecare dată când funcția este apelată.

Următorul exemplu prezintă mai multe definiții de funcții sub formă de instrucțiuni și expresii. Rețineți că definițiile funcției ca expresii sunt utile numai dacă fac parte din expresii mai mari, cum ar fi o atribuire sau un apel de funcție, care fac ceva cu funcția nou declarată:

// Tipărește numele și valorile tuturor proprietăților funcției obiect obj printprops(obj) ( for(var p în obj) console.log(p + ": " + obj[p] + "\n"); ) // Calculeaza distanta dintre punctele (x1,y1) si (x2,y2) function distance(x1, y1, x2, y2) ( var dx = x2 - x1; var dy = y2 - y1; return Math.sqrt(dx) *dx + dy*dy ) // Functie recursiva(intitulându-se), calculând funcția factorială factorial(x) ( dacă (x

Rețineți că în expresiile de definire a funcției, numele funcției poate să nu fie prezent. Instrucțiunea de declarare a funcției declară de fapt o variabilă și îi atribuie un obiect funcție.

O expresie de definiție a funcției, pe de altă parte, nu declară o variabilă. Cu toate acestea, în expresiile de definiție este posibil să se specifice numele funcției, ca în funcția factorială de mai sus, care poate fi necesar în corpul funcției pentru a se autodenomina. Dacă expresia definiției funcției include un nume, prenume se va referi la un obiect funcție din domeniul de aplicare al acelei funcții. De fapt, numele funcției devine o variabilă locală, accesibilă doar în corpul funcției. În cele mai multe cazuri, numele funcției nu trebuie să fie specificat în expresiile de definiție, făcând definițiile mai compacte.

Rețineți că majoritatea (dar nu toate) funcțiile din exemplu conțin o instrucțiune return. Instrucțiunea return termină funcția și returnează valoarea expresiei acesteia (dacă este specificată) programului apelant. Dacă nu există nicio expresie în instrucțiunea return, aceasta returnează nedefinit. Dacă nu există nicio instrucțiune return în funcție, interpretul va executa pur și simplu toate instrucțiunile din corpul funcției și va reveni nedefinit la programul apelant.

Majoritatea funcțiilor din exemplu evaluează la o anumită valoare și folosesc o instrucțiune return pentru a returna acea valoare programului apelant. Funcția printprops() este ușor diferită în acest sens: sarcina ei este de a tipări numele proprietăților unui obiect. Nu trebuie să returneze nicio valoare, deci nu există nicio instrucțiune return în funcție. Funcția printprops() va returna întotdeauna nedefinit. (Funcțiile care nu au o valoare returnată sunt uneori numite proceduri.)

Funcții de apelare

Codul de program care formează corpul unei funcții este executat nu în momentul în care funcția este definită, ci în momentul în care este apelată. Apelurile de funcții sunt efectuate folosind o expresie de apel. O expresie de apel constă dintr-o expresie de apel de funcție care returnează un obiect funcție, urmată de paranteze cu o listă separată prin virgulă de zero sau mai multe expresii argument în interior.

Dacă o expresie de apel de funcție este o expresie de apel de proprietate - dacă funcția este o proprietate de obiect sau un element de matrice (adică o metodă) - atunci expresia de apel este o expresie de apel de metodă. Următorul fragment arată câteva exemple de expresii de apel de funcții comune:

Elemente de imprimare((x:4, vârsta: 24)); var d = distanta(1,1,5,6); var f = factorial(5) / factorial(12); f = pătrat(5);

Când este apelată o funcție, toate expresiile de argument (specificate între paranteze) sunt evaluate, iar valorile rezultate sunt folosite ca argumente pentru funcție. Aceste valori sunt atribuite parametrilor ale căror nume sunt listate în definiția funcției. În corpul funcției, expresiile de apel ale parametrilor returnează valorile argumentelor corespunzătoare.

Când o funcție normală este apelată, valoarea returnată a funcției devine valoarea expresiei de apelare. Dacă o funcție revine după ce interpretul a ajuns la sfârșit, este returnat undefined. Dacă o funcție revine ca rezultat al unei instrucțiuni return, valoarea expresiei care urmează instrucțiunii return este returnată sau nedefinită dacă instrucțiunea return nu are nicio expresie.

O metodă nu este altceva decât o funcție care este stocată ca proprietate a unui obiect. Dacă aveți o funcție func și un obiect obj, atunci puteți defini o metodă pe obj numită metoda așa cum se arată mai jos:

// Definiți un obiect și o funcție simplă var obj = (); function func(a, b) ( return a+b;) // Adăugați o metodă la obiectul obj obj.method = func; // Acum puteți apela această metodă var result = obj.method(4, 5);

Cel mai adesea, atunci când apelați metode, utilizați operatorul punct pentru a accesa proprietăți, dar puteți folosi și forma parantezelor pătrate pentru a accesa proprietăți. De exemplu, ambele dintre următoarele expresii sunt expresii de apel de metodă:

Rezultat = obj.method(4, 5); rezultat = obj["metoda"](4, 5);

Argumentele și valoarea returnată a unui apel de metodă sunt procesate exact în același mod ca un apel de funcție normal. Cu toate acestea, apelul de metodă are un lucru diferenta importanta: contextul apelului. O expresie de acces la proprietate constă din două părți: un obiect (în în acest caz, obj) și numele proprietății (metodă). În astfel de expresii de apel de metodă, obj devine contextul de apelare, iar corpul funcției poate face referire la acel obiect folosind cuvântul cheie this. De exemplu:

Var obj = ( x: 0, y: 0, // Adăugați metoda: function(a, b) ( this.x = a; this.y = b; ), // O altă metodă sumă: function() ( return this .x + this.y ) ); // Apelarea metodelor obj.add(15, 4); console.log(obj.sum()); // 19

Metodele și cuvântul cheie this sunt centrale pentru paradigma de programare orientată pe obiecte. Orice funcție folosită ca metodă primește de fapt un argument implicit - obiectul pe care a fost apelată. De obicei, metodele efectuează anumite operații asupra unui obiect, iar sintaxa apelului de metodă reflectă în mod clar faptul că funcția operează asupra obiectului.

Vă rugăm să rețineți: acesta este un cuvânt cheie, nu o variabilă sau un nume de proprietate. Sintaxa JavaScript nu permite atribuirea de valori acestui element.

Argumente și parametrii funcției

În JavaScript, definițiile funcțiilor nu specifică tipurile de parametri, iar apelurile de funcție nu efectuează nicio verificare a tipului asupra valorilor argumentelor transmise. De fapt, JavaScript nici măcar nu verifică numărul de argumente atunci când apelează funcții. Subsecțiunile de mai jos descriu ce se întâmplă dacă numărul de argumente dintr-un apel de funcție este mai mic decât sau mai mult număr parametrii declarați. Ele demonstrează, de asemenea, cum puteți verifica în mod explicit tipurile de argumente ale unei funcții dacă trebuie să vă asigurați că funcția nu este apelată cu argumente nevalide.

Argumente opționale

Când numărul de argumente dintr-un apel de funcție este mai mic decât numărul de parametri declarați, argumentele lipsă sunt setate la nedefinit. Este adesea convenabil să scrieți funcții, astfel încât unele dintre argumente să fie opționale și să poată fi omise la apelarea funcției. În acest caz, este de dorit să se ofere posibilitatea de a atribui parametrilor care pot fi omisi valori implicite rezonabile rezonabile. De exemplu:

// Adăugați nume enumerabile ale // proprietăților obiectului obj în tabloul arr și returnați-l. Dacă argumentul // arr nu a fost transmis, creați și returnați o nouă funcție de matrice getPropertyNames(obj, /* opțional */ arr) ( dacă (arr === nedefinit) arr = ; // Dacă matricea nu este definită, creați a new for( var proprietate în obj) arr.push(property return arr // Această funcție poate fi apelată cu 1 sau 2 argumente: var a = getPropertyNames((x:1, y:1)); // Obține proprietățile obiectului într-o nouă matrice getPropertyNames((z:5),a); // adaugă proprietățile noului obiect la această matrice console.log(a); // ["x", "y", "z"]

Rețineți că atunci când declarați funcții, argumentele opționale trebuie să completeze lista de argumente pentru a fi omise. Programatorul care va scrie un apel la funcția dvs. nu va putea să treacă al doilea argument și, în același timp, să îl omite pe primul: va fi forțat să treacă în mod explicit valoarea nedefinită în primul argument. Observați și comentariul /* opțional */ din definiția funcției, care subliniază faptul că parametrul este opțional.

Liste de argumente cu lungime variabilă

Dacă numărul de argumente dintr-un apel de funcție depășește numărul de nume de parametri, funcția nu poate accesa direct valorile fără nume. Soluția la această problemă este oferită de obiectul Arguments. În corpul funcției, identificatorul de argumente se referă la obiectul Arguments prezent în apel. Obiectul Arguments este un obiect asemănător matricei care permite ca valorile transmise unei funcții să fie preluate prin numere, mai degrabă decât prin nume.

Să presupunem că a fost definită o funcție func care necesită un argument x. Dacă apelați această funcție cu două argumente, primul va fi disponibil în interiorul funcției cu numele parametrului x sau ca argumente. Al doilea argument va fi disponibil doar ca argumente. În plus, ca și tablourile reale, argumentele au o proprietate de lungime care specifică numărul de elemente pe care le conține. Adică în corpul unei funcții numită func cu două argumente, arguments.length are valoarea 2.

Obiectul Arguments poate fi folosit cel mai mult scopuri diferite. Următorul exemplu arată cum să îl utilizați pentru a verifica dacă o funcție a fost apelată cu numărul corect de argumente, ceva ce JavaScript nu va face pentru dvs.:

Funcția func(x, y, z) ( // Verifică mai întâi dacă este transmis numărul corect de argumente dacă (arguments.length != 3) ( throw new Error("Func numită cu argumente " + arguments.length + " și necesar 3."); ) // Și acum codul funcției în sine... )

Rețineți că adesea nu este necesar să verificați numărul de argumente, ca în acest exemplu. Comportamentul implicit al interpretului JavaScript este bun pentru majoritatea cazurilor: argumentele lipsă sunt înlocuite cu valoarea nedefinită, iar argumentele suplimentare sunt pur și simplu ignorate.

Obiectul Arguments ilustrează o caracteristică importantă a funcțiilor JavaScript: acestea pot fi scrise pentru a lua orice număr de argumente. Următoarea funcție ia orice număr de argumente și returnează valoarea celui mai mare (funcția încorporată Math.max() se comportă în mod similar):

Funcția maxNumber() ( var m = Number.NEGATIVE_INFINITY; // Buclă prin toate argumentele, găsiți și // stocați cel mai mare pentru (var i = 0; i m) m = argumente[i]; // Returnare cea mai mare valoareîntoarce m; ) var cea mai mare = maxNumber(1, 10, 100, 2, 3, 1000, 4, 5, 10000, 6); // 10000

Funcții ca aceasta care pot lua un număr arbitrar de argumente sunt numite funcții variadice, funcții de aritate variabilă sau funcții varargs. Acest termen a apărut odată cu apariția limbajului de programare C.

Rețineți că funcțiile variadice nu trebuie să fie apelate cu o listă de argumente goală. Este perfect logic să folosiți obiectul arguments atunci când scrieți o funcție care așteaptă un număr fix de argumente numite necesare, urmate de un număr arbitrar de argumente opționale fără nume.

Nu uitați că arguments nu este de fapt o matrice - este un obiect Arguments. Fiecare obiect Arguments are elemente de matrice numerotate și o proprietate de lungime, dar nu este din punct de vedere tehnic o matrice. Este mai bine să ne gândim la el ca la un obiect care are unele proprietăți numerotate.

Pe lângă elementele de matrice, obiectul Arguments definește proprietățile apelantului și apelantului. Încercarea de a schimba valorile acestor proprietăți în modul strict ECMAScript 5 este garantată pentru a arunca o excepție TypeError. Cu toate acestea, în modul lax, standardul ECMAScript afirmă că proprietatea apelat se referă la executabilul în în acest moment funcţie. Proprietatea apelantului nu este standard, dar este prezentă în multe implementări și se referă la funcția care a apelat-o pe cea curentă.

Proprietatea apelant poate fi folosită pentru a accesa stiva de apeluri, iar proprietatea apelant este utilă în special pentru apelarea recursiv a funcțiilor fără nume:

Var factorial = funcția(x) (dacă (x

Proprietăți și metode ale funcției

Am văzut că funcțiile pot fi folosite ca valori în programele JavaScript. Operatorul typeof returnează șirul „funcție” pentru funcții, dar funcțiile sunt de fapt un tip special de obiect în JavaScript. Și deoarece funcțiile sunt obiecte, ele au proprietăți și metode ca orice alte obiecte. Există chiar și un constructor Function() care creează noi obiecte funcție. Următoarele subsecțiuni descriu proprietățile și metodele funcțiilor.

proprietatea lungimii

În corpul funcției, proprietatea arguments.length specifică numărul de argumente transmise funcției. Cu toate acestea, proprietatea de lungime a funcției în sine are o semnificație diferită. Această proprietate numai în citire returnează numărul de argumente pe care funcția se așteaptă să le primească - numărul de parametri declarați.

Următorul fragment definește o funcție numită check() care primește o matrice de argumente de la o altă funcție. Acesta compară proprietatea arguments.length (numărul de argumente transmise efectiv) cu proprietatea arguments.callee.length (numărul de argumente așteptate) pentru a determina dacă funcției i-au fost transmise atâtea argumente cât se așteaptă. Dacă valorile nu se potrivesc, se face o excepție. Funcția check() este urmată de o funcție de testare, func(), care demonstrează cum se utilizează funcția check():

// Această funcție folosește arguments.callee, deci // nu va funcționa în modul strict function check(args) ( var actual = args.length; // Numărul real de argumente var așteptat = args.callee.length; // așteptat număr argumente if (actual !== așteptat) // Dacă nu se potrivesc, este aruncată o excepție throw new Error("așteptată: " + așteptat + "; primit " + actual ) funcția func(x, y, z) ( // Verificați numărul de argumente așteptate și trecute efectiv check(argumente // Executați restul funcției return x + y + z ) ;

proprietate prototip

Fiecare funcție are o proprietate prototip, care se referă la un obiect cunoscut sub numele de obiect prototip. Fiecare funcție are propriul său obiect prototip. Când o funcție este folosită ca constructor, obiectul nou creat moștenește proprietățile acelui obiect prototip.

Prototipurile și proprietatea prototipului au fost discutate într-un articol anterior.

metodele call() și apply().

Metodele call() și apply() vă permit să apelați o funcție indirect, ca și cum ar fi o metodă pe alt obiect. Primul argument pentru ambele metode call() și apply() este obiectul pe care este apelată funcția; acest argument specifică contextul apelului și devine valoarea cuvântului cheie this din corpul funcției. Pentru a apela func() (fără argumente) ca metodă de obj, puteți folosi oricare dintre metodele call() sau apply():

Func.call(obj); func.aplica(obj);

Oricare mod de a-l apela este echivalent cu următorul fragment (presupunând că obj nu are o proprietate numită m):

Obj.m = func; // Faceți temporar funcția o metodă obj obj.m(); // Numiți-o fără argumente. deleteobj.m; // Eliminați metoda temporară.

În modul strict ECMAScript 5, primul argument al metodelor call() și apply() devine valoarea acestuia, chiar dacă este o valoare simplă, nulă sau nedefinită. În ECMAScript 3 și în modul lax, valorile null și undefined sunt înlocuite cu obiectul global, iar valoarea simplă este înlocuită cu obiectul wrapper corespunzător.

Toate celelalte argumente ale metodei call() care urmează primului argument care specifică contextul de apelare sunt transmise funcției apelate. Metoda apply() acţionează ca metoda call(), cu excepţia faptului că argumentele funcţiei sunt transmise ca o matrice. Dacă o funcție este capabilă să proceseze un număr arbitrar de argumente, metoda apply() poate fi folosită pentru a apela o astfel de funcție în contextul unui tablou de lungime arbitrară.

Următorul exemplu demonstrează aplicare practică metoda call():

// Mai jos sunt două funcții care afișează proprietățile și // valorile proprietăților unui obiect arbitrar. Metoda // se afișează ca argument func function print1(func, obj) ( pentru (n în obj) func(n +": " + obj[n]); ) function print2(func, objDevice, obj) (pentru ( n în obj) func.call(objDevice, n +": " + obj[n] ) var obj = (x:5, y:10); print2(document.write, document, obj); // Funcționează corect print2(console.log, console, obj); print1(document.write, obj); // O excepție de invocare ilegală va apărea deoarece print1(console.log, obj); // este imposibil să apelați aceste metode fără un obiect context

metoda bind().

Metoda bind() a apărut pentru prima dată în ECMAScript 5, dar este ușor de imitat în ECMAScript 3. După cum sugerează și numele, scopul principal al metodei bind() este de a lega o funcție la un obiect. Dacă apelați metoda bind() a func și îi treceți un obiect obj, va returna o nouă funcție. Apelarea unei noi funcții (ca o funcție normală) va efectua apelul functia originala func ca metodă de obiect obj. Orice argumente transmise noii funcție vor fi transmise funcției inițiale. De exemplu:

// Funcția pe care doriți să o legați funcția func(y) ( return this.x + y; ) var obj = (x:1); // Obiect de legat la var g = func.bind(obj); // Apelarea g(x) va apela obj.func(x)

Acest tip de legare este ușor de implementat în ECMAScript 3, după cum se arată mai jos:

// Returnează o funcție care apelează func ca metodă de obiect obj // și îi transmite toate argumentele sale function bind(func, obj) ( if (func.bind) return func.bind(obj); // Folosește metoda bind dacă available else return function() ( // În caz contrar se leagă ca mai jos return func.apply(obj, arguments); )

Metoda bind() din ECMAScript 5 face mai mult decât să lege o funcție la un obiect. De asemenea, efectuează casting parțial: în plus față de această valoare, toate argumentele transmise metodei bind() după primul argument vor fi legate. Aplicarea parțială este o tehnică comună în programarea funcțională și uneori este numită curry.

Să începem cu faptul că limbajul JavaScript acceptă conceptul de POO (obiect programare orientată). Acest concept este că există elemente precum obiectele și aceste obiecte au diverse proprietăți și metode (funcții) care vă permit să le manipulați.

O funcție este un bloc separat de cod care constă dintr-unul sau mai multi operatori. Are propriul nume (unic) și poate lua diverși parametri, în funcție de care poate efectua una sau alta operație.

O metodă este, de asemenea, o funcție, dar aparține deja unei clase sau obiecte.

Pentru a apela o metodă, trebuie mai întâi să scrieți numele obiectului, apoi să scrieți numele metodei despărțit de un punct. Excepția de la această regulă este atunci când apelați metodele alert(), confirm() și prompt() ale obiectului fereastră. Ele pot fi apelate fără a specifica numele obiectului. Ne-am familiarizat deja cu aceste metode în acest articol.

De asemenea, în articolele anterioare am fost introdus în metoda de ieșire document.write(), care aparține obiectului document.

Deci, în programare există o oportunitate foarte importantă, și anume că îți poți crea propriile funcții.

Sintaxa funcției arată astfel:


De exemplu, să creăm funcție simplă, care va adăuga textul transmis la paragraf și îl va afișa. Și îl va face, de asemenea, îndrăzneț și italic.

Funcția writeText(text)( //Adăugați text în paragraf și afișați-l document.write("

„+text+”

"); ) //Apelați funcția creată writeText ("Bună ziua!");

Salvați documentul și deschideți-l în browser.


Comentariu! La declararea unei funcții trebuie să fie prezente acolade, indiferent de câți operatori sunt.

Care sunt funcțiile necesare în programare?

Principalul avantaj al utilizării funcției este reducerea dimensiunii cod sursă scenariu.

Să presupunem că trebuie să iterăm peste trei tablouri unidimensionale. După cum știm din acest articol: , matricea este iterată folosind o buclă. Fără funcție, codul pentru acest script va arăta astfel:

//declară trei tablouri var arr1 = ; var arr2 = ["b", 5, 9,2, "h", 8, 2]; var arr2 = ; pentru(var i = 0; i< arr1.length; i++){ document.write("

Elementul de matrice arr1, cu indexul " + i + " este egal cu: "+ arr1[i] +"

"); ) pentru (var i = 0; i< arr2.length; i++){ document.write("

Elementul de matrice arr2, cu indexul " + i + " este egal cu: "+ arr2[i] +"

"); ) pentru (var i = 0; i< arr3.length; i++){ document.write("

Elementul de matrice arr3, cu indexul " + i + " este egal cu: "+ arr3[i] +"

"); }

Deci, pentru a nu scrie propria buclă pentru fiecare matrice, este mai bine să folosiți o funcție în care trecem matricea, iar aceasta își va afișa toate elementele pe ecran. Astfel, în primul rând, reducem dimensiunea codului și, în al doilea rând, scăpăm de repetarea codului.

Funcția printArr(arr)( for(var i = 0; i< arr.length; i++){ document.write("

Elementul matricei cu indicele „ + i + ” este egal cu: „+ arr[i] +”

"); ) ) //declară trei tablouri var arr1 = ; var arr2 = ["b", 5, 9.2, "h", 8, 2]; var arr2 = ; //Apelați funcția creată pentru a itera prin fiecare matrice printArr (arr1); printArr(arr2);

Parametrii funcției

O funcție poate lua orice număr de parametri, de la unu la infinit. Sau, poate fi complet fără parametri.

Să creăm o funcție fără parametri care imprimă pur și simplu fraza clasică „Hello world” pe ecran.

Funcția helloWorld())( document.write("Hello World"); ) //Apelați funcția fără parametri, helloWorld helloWorld();

Orice parametru de funcție poate avea propria sa valoare implicită. Aceasta înseamnă că dacă nu trecem nicio valoare atunci când apelăm funcția acest parametru

De exemplu, să creăm o funcție care adaugă două numere trecute. Dacă trecem doar un număr, atunci, implicit, al doilea număr va fi 4.

Funcția summa(număr1, număr2 = 4)( document.write("

Suma numerelor " + număr1 + " (Primul parametru) și " + numărul2 + " (Al doilea parametru) este egală cu: " + (numărul1 + numărul2) + "

"); ) //Apelați o funcție care, implicit, va scoate rezultatul adunării numărului trecut, cu numărul 4. summa(5); // Rezultat: 9 //Dacă furnizăm și al doilea parametru, funcția va afișa rezultatul adunării numerelor din ambii parametri .summa(5, 20) // Rezultat: 25;

De asemenea, este posibil ca în interiorul unei funcții să se poată apela o altă funcție existentă.

De exemplu, să apelăm prima funcție pe care am creat-o, writeText(), în cadrul funcției anterioare summa(). Vom transmite rezultatul adăugării de numere la funcția writeText(). În acest caz, codul pentru funcția summa() va arăta astfel:

Funcția summa(număr1, număr2 = 4)( scrieText(număr1 + număr2); ) //Apelați funcția summa summa(5); // Rezultat: 9 summa(5, 20); // Rezultat: 25

Funcții care returnează o anumită valoare

Până acum avem funcții scrise care afișează imediat rezultatul pe ecran.

Acum să învățăm cum să scriem o funcție care returnează un rezultat. Putem adăuga acest rezultat la o variabilă și putem lucra cu el în continuare.

Pentru a înțelege mai bine despre ce vorbim, să ne amintim metode precum prompt() și confirm(). Aceste metode returnează de fapt valoarea primită de la utilizator, mai degrabă decât să o afișeze.

De exemplu, să creăm propria noastră funcție care va returna ultimul element al matricei transmis ca parametru.

Funcția lastElement(arr)( //Return ultimul element al matricei transmise return arr; ) //Declară matricea var otherArr = ["iphone", "asus", 2000, 9.8, "twix"]; //Apelați funcția creată lastElement și transmiteți-i matricea creată ca parametru otherArr var lastEl = lastElement(otherArr); //Afișează ultimul element rezultat al matricei alert(lastEl);

Ca rezultat, vom obține cuvântul „twix”, deoarece acest cuvânt este ultimul element al matricei otherArr.

Metoda alert() nu returnează nimic. Adică, dacă încercăm să afișăm o variabilă al cărei tip conține rezultatul apelării metodei alert(), vom vedea valoarea undefined . Este același lucru cu încercarea de a afișa valoarea unei variabile goale.

De exemplu, să luăm rezultatul ultimul apel alert() din exemplul anterior, puneți-o în variabila resAlert și utilizați funcția writeText pe care am creat-o pentru a încerca să afișați rezultatul.

//Afișează ultimul element primit al matricei var resAlert = alert(lastEl); test var; scrieText(resAlert); // scrieText nedefinit(test); //nedefinit

După cum puteți vedea, în ambele cazuri am primit valoarea nedefinită.

Variabile globale și locale

Variabilele globale sunt acele variabile care sunt declarate în afara funcției. Adică, toate acele variabile care nu sunt declarate în interiorul funcției în sine sunt globale. Sunt vizibile (valide) pe tot parcursul documentului.

Variabilele locale sunt acele variabile care sunt declarate în cadrul funcției în sine. Și sunt valabile numai în cadrul unei anumite funcții. În afara acestuia, variabilele locale nu vor mai funcționa.

Variabilele locale și globale nu sunt legate între ele în niciun fel.


În exemplul din imagine, dacă am încerca să afișăm conținutul variabilei x, am primi un mesaj nedefinit deoarece am uitat să apelăm funcția other().

Prin urmare, pentru ca modificările făcute în interiorul funcției să funcționeze, este necesar să apelați această funcție.

Apelăm funcția other() și dacă acum încercăm să afișăm valoarea variabilei x, vom vedea ca rezultat numărul 4.

Pentru a accesa o variabilă globală din interiorul unei funcții, nu trebuie să faceți nimic, trebuie doar să o utilizați. Modificările aduse variabilelor globale vor fi vizibile în afara funcției.

Var x = 8; function increment() ( x++; ) //Apeleaza functia increment() increment(); alertă(x); //Rezultat: 9

Dacă nu dorim ca variabila globală să se modifice, trebuie să declarăm o variabilă locală (eventual cu același nume cu cea globală) și toate acțiunile vor fi efectuate asupra acesteia.

Var g = 100; funcția func())( var g = 14; g *= 2; // Este la fel ca g = g * 2 alert(g); // Rezultat: 28 ) // Apelați funcția. func(); alert(g);//Rezultat: 100

Asta e tot, dragi cititori, acum știți ce este o funcție, cum să vă creați propria funcție, cum să apelați o funcție și ce tipuri de funcții există. De asemenea, ați învățat ce sunt variabilele globale și locale.

După cum am scris la începutul articolului, funcțiile sunt elemente foarte importante, așa că ar trebui să le cunoașteți perfect.

Sarcini
  • Creați o funcție care ia două numere ca parametri și returnează rezultatul înmulțirii acestor numere.
  • Imprimați rezultatul.

    • Articol în curs de dezvoltare!

    Un articol în care vom lua în considerare ce este o funcție, precum și versiunea tradițională (clasică) a lucrului cu ea. În plus, vom analiza care sunt argumentele (parametrii) funcției și operatorul return.

    Ce este o funcție?

    O funcție este un set de instrucțiuni cărora li se poate da un nume și apoi accesat cu acel nume de oriunde în program.

    Un exemplu clasic de utilizare a unei funcții. Pagina web are Cod JavaScript

    , oarecare fragment în care se repetă de mai multe ori. Pentru a evita acest lucru, puteți formata acest fragment ca funcție și apoi îl puteți apela în locurile necesare din cod folosind numele acestei funcție. Apelarea acestei funcții va însemna executarea instrucțiunilor conținute în ea.

    • Cum se organizează execuția unei sarcini în JavaScript folosind funcții? Pentru a face acest lucru, de obicei procedați astfel:
    • împărțiți sarcina în părțile sale componente (subsarcini);
    • subsarcinile sunt formalizate prin funcții;

    dezvolta codul principal folosind apeluri la functiile create.

    Ca urmare, un astfel de program devine mai structurat. Este mai ușor să faceți diverse modificări și să adăugați funcții noi.

    Declararea și apelarea unei funcții

    • Operațiile cu o funcție în JavaScript pot fi împărțite în 2 pași:
    • declararea (crearea) unei funcţii.

    apelați (executați) această funcție.

    Declarație de funcție.

    Crearea unei funcții în JavaScript începe cu scrierea cuvântului cheie al funcției, urmat de numele funcției, apoi parametrii sunt enumerați în paranteze, dacă este necesar, urmați de instrucțiuni, care sunt încadrate între acolade.

    // declarația funcției someName function someName() ( alert("Ați apelat funcția someName!"); ) JavaScript - Sintaxa declarației funcției

    Funcțiile de acest fel în JavaScript sunt numite declarații de funcție. Pe lângă acest tip, JavaScript face distincție între expresia de definire a funcției și funcțiile de expresie a funcției săgeată.

    Un set de instrucțiuni cuprinse între acolade este codul funcției care va fi executat atunci când este apelat.

    Apel de funcție.

    Funcția declarată în sine nu va fi executată. Pentru a-l rula, trebuie apelat. O funcție este apelată prin specificarea numelui și a două paranteze. Argumentele sunt specificate în paranteze dacă este necesar.

    // apelează funcția dată în exemplul anterior someName();

    JavaScript - Sintaxă a apelului de funcție

    Este o funcție un obiect în JavaScript?

    Funcțiile din JavaScript sunt obiecte.

    În JavaScript, totul este un obiect, cu excepția celor șase tipuri de date primitive. Și dacă funcția este un obiect, atunci o referință la aceasta poate fi stocată într-o variabilă.

    // declarația funcției someName function someName() ( alert("Ați apelat funcția someName!"); ) var reference = someName;

    După aceasta, puteți apela funcția astfel:

    Referinţă();

    Parametrii și argumentele funcției

    Argumentele funcției sunt valori care sunt transmise unei funcții atunci când este apelată. Argumentele sunt separate unele de altele folosind o virgulă.

    // apelează funcția sayWelcome trecându-i două argumente sayWelcome("Ivan", "Ivanov"); // un alt apel la funcția sayWelcome cu două argumente sayWelcome("Peter", "Petrov");

    Parametrii funcției sunt una dintre modalitățile din JavaScript prin care puteți accesa argumentele dintr-o funcție. Parametrii funcției în stadiul declarării acesteia sunt descriși în paranteze.

    Cu alte cuvinte, parametrii funcției sunt variabile locale care sunt create automat atunci când funcția este lansată. Parametrii primesc ca valori argumentele corespunzătoare transmise funcției în timpul apelului acesteia. Puteți accesa parametrii numai în interiorul acestei funcții, nu există;

    // se apelează funcția sayWelcome și îi trece un argument sayWelcome("Peter"); // Bun venit, Peter nedefinit // apelând funcția sayWelcome fără a-i transmite niciun argument sayWelcome(); // Bun venit, undefined undefined

    Un exemplu de funcție care pur și simplu va scoate argumentele transmise către consola browserului:

    // declararea funcției funcția outputParam(param1, param2, param3) ( console.log(param1 + "; " + param2 + "; " + param3); ) // apelează la funcția outputParam care o transmite cantități diferite parametri outputParam("Ploaie","Zăpadă","Ceata"); // Ploaie; Zăpadă; Ieșire ceațăParam(17); // 17; nedefinit; outputParam nedefinit(24,33); // 24; 33; nedefinit outputParam(); // nedefinit; nedefinit; nedefinit

    O altă modalitate de a accesa argumentele dintr-o funcție este utilizarea obiectului argumente speciale. Argumentele sunt accesate prin argumente în același mod ca elementele unui tablou obișnuit, de exemplu. după numerele lor de serie. Astfel, argument - vă va permite să obțineți primul argument, argumente - al doilea argument etc.

    // declarație funcție sum function sum(num1, num2) ( /* num1 sau argumente – obține valoarea argumentului 1 num2 sau argumente – obține valoarea argumentului 2 */ var sum1 = num1 + num2, sum2 = argumente + argumente; return „Suma, obținută prin prima metodă este egală cu „ + sum1 + „; suma obținută prin metoda a 2-a este „ + sum2 ) /* trimite rezultatul funcției sum în consola 7 - primul argument (it poate fi accesat fie prin numele num1, fie folosind argumente) 4 - al doilea argument (poate fi accesat fie prin numele num2, fie folosind argumente) */ console.log(sum(7,4));

    Principala diferență dintre aceste metode este că prima dintre ele vă permite să accesați doar acele argumente cărora li sa dat nume în etapa de declarare a funcției. A doua metodă vă permite să obțineți valoarea oricărui argument, chiar dacă acesta nu are un nume (după numărul de serie). Aceasta este o oportunitate limbaj JavaScript vă permite să creați funcții universale flexibile.

    Pe lângă primirea argumentelor, obiectul arguments vă permite și să cunoașteți numărul acestora. Acest lucru se face folosind proprietatea length.

    Puteți repeta peste argumentele transmise funcției, de exemplu, folosind pentru buclă sau pentru...de .

    // declarația funcției sum funcția sum() ( var i = 0; console.log ("Ieșire toate argumentele folosind o buclă for"); for (i; i< arguments.length; i++) { console.log(i + 1 + " аргумент равен " + arguments[i]); } console.log("Вывод всех аргументов с помощью цикла for...of"); for (arg of arguments) { console.log(arg); } } // вызов функции sum sum(7, 4, 3, 1);

    O funcție care afișează consolei toate argumentele transmise acesteia și numărul acestora:

    // declararea funcției funcția myFunction () ( var i; console.log("Numărul de parametri trecuți = " + arguments.length); // să parcurgem toți parametrii folosind o buclă for for (i = 0; i< arguments.length; i++) { console.log(i + " параметр = " + arguments[i]); } } // вызовы функции myFunction myFunction(3, 7, 27, "JavaScript"); myFunction(); myFunction("Яблоки", "Груши", "Апельсины");

    O funcție care efectuează adăugarea tuturor argumentelor transmise acesteia (numărul acestora este necunoscut în prealabil):

    // declarația funcției var myCalc = function() ( // să parcurgem toți parametrii folosind bucla for var i, sum = 0; for (i = 0; i lt; arguments.length; i++) ( sum += arguments [i] ; ) // returnează suma ca rezultat returnează sumă ) // apel de funcție (ieșire în consolă) console.log(myCalc(4, 20, 17, -6));

    Ca rezultat, folosind obiectul arguments puteți implementa următoarele în corpul funcției:

    • verificarea numărului de argumente transmise;
    • procesând orice număr de parametri.

    Pe lângă funcția în sine, alte funcții aflate în ea au acces și la argumentele care îi sunt transmise în faza de apel.

    Funcția mainF(p1, p2) ( function childF() ( console.log("p1 = " + p1 + "; p2 = " + p2); ) childF(); ) mainF(3, 5); // p1 = 3; p2 = 5 mainF(4, 7); // p1 = 4; p2 = 7

    Setări implicite

    Începând cu ECMAScript 2015 (6), un parametru de funcție poate fi setat la valoarea sa implicită.

    De exemplu, să setăm parametrul „culoare” la valoarea sa implicită, egală cu „#009688”:

    Funcția setBGColor(culoare = "#009688") ( document.body.style.backgroundColor = culoare; ) setBGColor(); // culoarea de fundal va fi #009688 setBGColor(„red”); // culoarea de fundal va fi roșie

    Înainte de ECMAScript 2015, puteți seta parametrul la valoarea sa implicită, de exemplu, astfel:

    Funcția setBGColor(culoare) (culoare = culoare !== nedefinită ? culoare: „#009688”; // setează culoarea la valoarea implicită „#009688” document.body.style.backgroundColor = culoare; )

    Parametrii rămași

    Dacă, atunci când apelați o funcție, îi transmiteți mai multe argumente decât are parametrii, atunci îi puteți obține pe cei rămași folosind așa-numiții patametre de repaus. Această oportunitate a apărut în limbajul începând cu ECMAScript 2015.

    // ...nums - restul parametrilor, care pot fi accesați în acest caz prin nume nums function doMath(mathAction, ...nums) ( var rezultat = 0; nums.forEach(function(value)) ( ​​switch ( mathAction) ( caz "sumă": rezultat += valoare; break; rezultat = 0; ) returnează rezultatul ) console.log(doMath("sum", 3, 4, 21, -4)); // 24 (3 + 4 + 21 + (-4)) console.log(doMath("sumSquare", 1, 4)); // 17 (1^2 + 4^2) console.log(doMath("sumCube", 3, 2, 4)); // 99 (3^3 + 2^3 + 4^3)

    declarație de returnare

    Instrucțiunea return are scopul de a returna o valoare sau rezultatul evaluării unei expresii functia curenta. Valoarea sau expresia trebuie separată de returnare printr-un spațiu. În plus, instrucțiunea return oprește execuția funcției, adică. toate instrucțiunile care le urmează nu vor fi executate.

    O funcție din JavaScript returnează întotdeauna un rezultat, indiferent dacă este folosită sau nu o instrucțiune return.

    // funcție care returnează funcția de rezultat sayWelcome (userFirstName, userLastName) ( if (!userFirstName) || (!userLastName)) returnează „Bun venit, utilizator anonim”; altfel returnează „Welcome,” + userLastName + " " + userFirstName ; ) // declarație variabilă person var person; // atribuiți rezultatul funcției sayWelcome variabilei persoană person = sayWelcome("Ivan","Ivanov"); // printeaza valoarea variabilei in consola console.log(persoana); //Instrucțiune care va afișa în consolă rezultatul funcției sayWelcome console.log(sayWelcome("Petr","Petrov")); //Instrucțiune care va afișa în consolă rezultatul funcției sayWelcome console.log(sayWelcome("Sidorov"));

    JavaScript - Funcție cu verificarea parametrilor

    // 1. funcție care nu returnează nicio funcție de rezultat sayWelcome (userFirstName, userLastName) ( console.log("Welcome, " + userLastName + " " + userFirstName); ) // să încercăm să obținem un rezultat dintr-o funcție care nu nu returnează nimic console .log(sayWelcome("Ivan", "Ivanov")); // 2. funcție care conține o instrucțiune return fără o funcție de valoare sayDay (day) ( zi = "Azi," + zi; return; //această instrucțiune nu va fi executată deoarece vine după instrucțiunea return console.log(day) ; ) // să încercăm să obținem rezultatul dintr-o funcție care conține o instrucțiune return fără valoare console.log(sayDay("21 februarie 2016"));

    JavaScript - Obține valoare dintr-o funcție care nu returnează nimic

    Același rezultat va fi obținut dacă instrucțiunea return nu specifică o valoare returnată.

    Supraîncărcarea funcției în JavaScript Supraîncărcarea funcțiilor în programare este capacitatea de a declara mai multe funcții cu aceleasi nume

    într-un singur domeniu. Astfel de funcții diferă între ele prin tipul și numărul de argumente. Fiecare funcție are propria sa logică de program. Supraîncărcarea funcției este utilizată astfel încât acțiuni similare să poată fi efectuate folosind un singur nume de funcție. Limbajul JavaScript nu acceptă supraîncărcarea funcțiilor în același mod în care este implementat, de exemplu, în C limbi similare

    . Aceste. În JavaScript, nu puteți crea mai multe funcții cu aceleași nume care sunt în același domeniu.

    • Funcționalități similare pot fi implementate în JavaScript utilizând următorii pași:
    • Pentru a verifica dacă un argument este transmis sau nu, utilizați o condiție care verifică valoarea acestuia pentru undefined .
    • Pentru a verifica numărul de argumente transmise unei funcții, utilizați proprietatea lungimii argumente a obiectului.
    • Pentru a afla tipul valorii argument transmis, utilizați operatorii typeof sau instanceof.
    • Pentru a lucra cu un număr variabil de argumente, utilizați obiectul arguments.

    Începând cu ECMAScript6, puteți specifica valori implicite pentru argumente.

    De exemplu, să creăm o funcție care poate fi apelată cu unul sau două argumente: //declararea unei funcții care își schimbă culoarea funcția elemente setBgColor(bgColor,elements) ( //dacă parametrul elementelor nu este specificat la apelarea if (elements=== nedefinit) ( //apoi setați valoarea la „div” elements = „div”; ) //get all elemente elemente = $(elemente) // iterează prin toate elementele și setează-le la culoarea de fundal specificată elements.each(function())( $(this).css("background-color",bgColor); )) / *Apelați funcția setBgColor, specificând un parametru. Deoarece 2 nu este specificat, atunci această funcție va schimba culoarea de fundal a tuturor elementelor div.*/ setBgColor("verde"); /*Apelați funcția setBgColor, specificând 2 parametri. Deoarece 2 este specificat, atunci

    această funcție

    va schimba doar culoarea de fundal a elementelor butonului.*/ setBgColor("#ff0000","button");

    Să facem câteva modificări codului de mai sus. Și anume, specificăm valoarea implicită pentru al doilea parametru:

    //declararea unei funcții care modifică culoarea de fundal a elementelor //parametrul elemente are valoarea "div" implicit funcția setBgColor(bgColor,elements = "div") ( //get all elements elements = $(elements); //iterează toate elementele și setează-le la culoarea de fundal specificată elements.each(function())( $(this).css("background-color",bgColor); ) ) //apelează funcția setBgColor, specificând un parametru setBgColor("verde"); //apelați funcția setBgColor, specificând 2 parametri setBgColor("#ff0000","button");

    Un exemplu despre cum în JavaScript puteți implementa o funcție „supraîncărcată” care calculează numărul de calorii de care are nevoie o persoană pe zi:

    // descrierea funcției funcției countCal(sex, înălțime) ( // parametrii: sex (sex) și înălțime (înălțime) var rezultat; if ((sex === 0) || (sex === „bărbat”) ) ( rezultat = (înălțime - 100) * 20; ) else if ((sex === 1) || (sex === „femeie”)) ( rezultat = (înălțime - 105) * 19; ) dacă (rezultat ) ( // argumente - nivel de activitate if (argumente) ( rezultat *= argumente; ) console.log("Cantitatea de kcal pentru viața normală: " + rezultat) else ( console.log ("Parametri incorecți"); ) ) / * apelarea unei funcții și transmiterea a 2 argumente acesteia (1 - „om”, poate fi accesată folosind numele sex și argumente; 2 - valoarea 185, poate fi accesată folosind numele sex și argumente) */ countCal(" om", 185); /* apelarea unei funcții și transmiterea ei a 3 parametri, deși doar 2 sunt prezenți în descrierea funcției (în acest caz, puteți obține valoarea celui de-al 3-lea parametru doar ca argumente) */ countCal(0, 185, 2);

    O funcție este de obicei apelată în funcție de modul în care este declarată după nume sau de o variabilă care conține o referință la funcție.

    Funcția fact(n) ( if (n === 1) ( return 1; ) return fact(n-1) * n; ) console.log(fact(5)); // 120

    Puteți apela o funcție în corpul său nu numai după nume, ci și folosind proprietatea apelat a obiectului arguments. Dar această proprietate Este mai bine să nu-l folosești, pentru că... este depășit. În plus, în modul strict nu funcționează deloc.

    Ce sunt funcțiile încorporate (standard)?

    JavaScript are un set imens de funcții încorporate (standard). Aceste funcții sunt deja descrise în motorul browserului însuși. Aproape toate sunt metode ale unui obiect sau altul.

    De exemplu, pentru a apela alerta de funcție (metodă) încorporată, nu trebuie să fie declarată mai întâi. Este deja descris în browser. Metoda de alertă este apelată prin specificarea unui nume, a parantezelor și a unui argument în interiorul acestora. Această metodă conceput pentru a afișa un mesaj pe ecran sub forma unei casete de dialog. Mesaj text este luat din valoarea parametrului acestei funcții.

    // apelarea funcției de alertă alert("Un text");

    JavaScript - Apelarea funcției de alertă

    9 răspunsuri Există mai multe moduri de a gestiona evenimente folosind HTML/DOM. Nu există o cale adevărată sau greșită, dar moduri diferite

    util în diferite situații.

    1: îl definește în HTML:

    2: Adăugați-l la proprietatea DOM a evenimentului în Javascript:

    //- Folosind un indicator de funcție: document.getElementById("clickMe").onclick = doFunction; //- Folosind o funcție anonimă: document.getElementById("clickMe").onclick = function () ( alert("hello!"); );

    3: Și adaugă o funcție la handlerul de evenimente folosind Javascript:

    Var el = document.getElementById("clickMe"); if (el.addEventListener) el.addEventListener("click", doFunction, false); else if (el.attachEvent) el.attachEvent("onclick", doFunction);

    Atât a doua cât și a treia metodă permit funcții inline/anonime și ambele trebuie declarate după ce elementul a fost analizat din document. Prima metodă nu este XHTML validă deoarece atributul onclick nu este specificat în specificația XHTML.

    Cel mai probabil, problema este undeva în funcția ta CapacityChart(). După ce accesați linkul și rulați scriptul, funcția CapacityChart() rulează și se deschid două ferestre pop-up (una dintre ele închisă conform scriptului). Dacă aveți următoarea linie:

    CapacityWindow.document.write(s);

    Încearcă asta în schimb:

    CapacityWindow.document.open("text/html"); CapacityWindow.document.write(s); CapacityWindow.document.close();

    SCHIMBA
    Când am văzut codul tău, am crezut că îl scrii special pentru IE. După cum sa menționat, va trebui să înlocuiți referințele la document.all cu document.getElementById . Cu toate acestea, va trebui totuși să remediați scriptul după aceasta, așa că aș recomanda ca acesta să funcționeze cel puțin în IE, deoarece orice greșeală pe care o faceți prin schimbarea codului pentru a funcționa între browsere ar putea provoca și mai multă confuzie. Odată ce funcționează în IE, va fi mai ușor să vedeți dacă funcționează în alte browsere în timp ce actualizați codul.

    Aș spune că ar fi mai bine să adăugați javascript într-o manieră discretă...

    dacă utilizați jQuery, puteți face ceva de genul:

    $(document).ready(function())( $("#MyButton").click(function())( CapacityChart(); ));

    HTML-ul dvs. și modul în care apelați funcția de la buton arată corect.

    Problema este în funcția CapacityCount. Primesc această eroare în consola mea pe Firefox 3.5: „document.all is undefined” pe linia 759 din bendelcorp.js.

    Se pare că document.all este doar IE și este într-un mod non-standard acces DOM. Dacă utilizați document.getElementById(), acest lucru ar trebui să funcționeze. Exemplu: document.getElementById("RUnits").value în loc de document.all.Capacity.RUnits.value

    Una dintre principalele probleme cu care te confrunți este atunci când folosești browserul sniffing fără un motiv întemeiat:

    If(navigator.appName == "Netscape") ( vesdiameter = document.forms["Volum"].elements["VesDiameter"].value; // mai multe lucruri tăiate ) else ( vesdiameter = eval(document.all.Volume. VesDiameter.value); // mai multe lucruri tăiate )

    Sunt pe Chrome, așa că navigator.appName nu va fi Netscape . Chrome acceptă document.all? Poate, dar din nou, poate nu. Dar alte browsere?

    Versiunea codului din furca Netscape ar trebui să funcționeze în orice browser înapoi la Netscape Navigator 2 din 1996, așa că probabil ar trebui să rămâneți cu asta... cu excepția faptului că nu va funcționa (sau nu este garantat să funcționeze), deoarece nu ai specificat atributul numelui pentru elementele de intrare, astfel încât acestea nu vor fi adăugate la matricea de elemente din formular ca elemente numite:

    Fie dați-le un nume și folosiți o matrice de elemente, fie (mai bine) folosiți

    Var vesdiameter = document.getElementById("VesDiameter").value;

    care va funcționa pentru toată lumea browsere moderne- nu necesită ramificare. Pentru a fi sigur, înlocuiți-l prin adulmecarea versiunii de browser mai mare sau egală cu 4, cu o verificare a suportului pentru getElementById:

    Dacă (document.getElementById) ( // NB: fără paranteze; testăm existența metodei, nu o executăm // facem lucruri... )

    Probabil că veți dori, de asemenea, să vă validați intrarea; ceva de genul

    Var vesdiameter = parseFloat(document.getElementById("VesDiameter").value); if (esteNaN(vesdiametru)) (alertă(„Diametrul ar trebui să fie numeric”); return; )

    Ultima actualizare: 04/09/2018

    Funcțiile sunt un set de instrucțiuni care efectuează acțiune specifică sau calcularea unei anumite valori.

    Sintaxa definirii functiei:

    Funcția nume_funcție([parametru [, ...]])( // Instrucțiuni )

    O definiție a funcției începe cu cuvântul cheie funcție urmat de numele funcției. Un nume de funcție urmează aceleași reguli ca și un nume de variabilă: poate conține doar cifre, litere, litere de subliniere și caractere dolari ($) și trebuie să înceapă cu o literă, liniuță de subliniere sau dolar.

    După numele funcției, parametrii sunt listați în paranteze. Chiar dacă o funcție nu are parametri, pur și simplu conține paranteze goale. Apoi, în acolade, vine corpul funcției, care conține un set de instrucțiuni.

    Să definim cea mai simplă funcție:

    Funcția display())( document.write("funcție în JavaScript"); )

    Această funcție se numește display(). Nu acceptă niciun parametru și tot ce face este să scrie un șir pe pagina web.

    Cu toate acestea definiție simplă Caracteristica nu este încă suficientă pentru a funcționa. Mai trebuie să o suni:

    function display())( document.write("functie in JavaScript"); ) display();

    Nu este necesar să dați funcțiilor un nume specific. Puteți utiliza funcții anonime:

    Var display = function())( // definitia functiei document.write("function in JavaScript"); ) display();

    Ceea ce facem este să definim de fapt o variabilă de afișare și să îi atribuim o referință de funcție. Și apoi după nume functie variabila numit.

    De asemenea, putem atribui dinamic funcții unei variabile:

    Funcția goodMorning())( document.write("Bună dimineața"); ) function goodEvening())( document.write("Bună seara"); ) var mesaj = goodMorning; mesaj(); // Mesaj de bună dimineață = goodEvening; mesaj(); // Bună seara

    Parametrii funcției

    Să luăm în considerare trecerea parametrilor:

    Afișare funcție(x)( // definiția funcției var z = x * x; document.write(x + " pătrat este egal cu " + z); ) afișare(5); // apel de funcție

    Funcția de afișare preia un parametru - x. Prin urmare, atunci când apelăm o funcție, putem transmite o valoare pentru aceasta, de exemplu, numărul 5, ca în acest caz.

    Dacă o funcție ia mai mulți parametri, atunci folosind operatorul de răspândire... putem trece un set de valori pentru acești parametri dintr-o matrice:

    Funcția sum(a, b, c)( fie d = a + b + c; console.log(d); ) sum(1, 2, 3); fie numere = ; suma(...nums);

    În al doilea caz, numerele din tabloul nums sunt transmise funcției. Dar pentru a transmite nu doar o matrice ca o singură valoare, ci numere din această matrice, se folosește operatorul de răspândire (elipse...).

    Parametri opționali

    O funcție poate lua mulți parametri, dar unii sau toți parametrii pot fi opționali. Dacă nu se transmite nicio valoare pentru parametri, aceștia sunt implicit „nedefinit”.

    Afișare funcție (x, y)( dacă (y === nedefinit) y = 5; dacă (x === nedefinit) x = 8; fie z = x * y; console.log(z); ) afișare () ; // 40 display(6); // 30 afișare (6, 4) // 24

    Aici funcția de afișare preia doi parametri. Când apelăm o funcție, putem verifica valorile acestora. Cu toate acestea, atunci când apelați o funcție, nu este necesar să transmiteți valori pentru acești parametri. Pentru a verifica prezența valorilor parametrilor, se utilizează o comparație cu valoarea nedefinită.

    Există o altă modalitate de a defini valorile implicite pentru parametri:

    Funcția afișare(x = 5, y = 10)( fie z = x * y; console.log(z); ) afișare(); // 50 afișare(6); // 60 afișare (6, 4) // 24

    Dacă nu sunt transmise valori parametrilor x și y, acestea sunt obținute ca valori ale numerelor 5 și, respectiv, 10. Această metodă este mai concisă și intuitivă decât compararea cu nedefinită.

    În acest caz, valoarea implicită a parametrului poate fi derivată, reprezentând expresia:

    Afișare funcție(x = 5, y = 10 + x)( fie z = x * y; console.log(z); ) afișare(); // 75 display(6); // 96 afișare (6, 4) // 24

    În acest caz, valoarea parametrului y depinde de valoarea lui x.

    Dacă este necesar, putem obține toți parametrii trecuți prin matricea de argumente accesibilă global:

    Funcția display())( var z = 1; for(var i=0; i