Oamenii cred că științele informatice sunt arta pentru genii. În realitate, opusul este doar o mulțime de oameni fac ca lucrurile care se află unul pe celălalt par să facă un zid de mici pietricele.

Donald Knut.

Ați văzut deja provocări ale funcțiilor, cum ar fi alertă. Funcțiile sunt pâine cu ulei de programare pe JavaScript. Ideea de a împacheta o bucată de program și de ao numi ca o variabilă este foarte solicitată. Acesta este un instrument pentru structurarea unor programe mari, reducerea repetițiilor, atribuirea de nume subrutine și izolarea subrutine unul de celălalt.

Cea mai evidentă utilizare a funcțiilor este crearea unui nou dicționar. Inventați cuvintele pentru proza \u200b\u200bumană obișnuită - un ton rău. În limba de programare este necesar.

Mid adult omul de limbă rusă știe aproximativ 10.000 de cuvinte. Un limbaj de programare rar conține 10.000 de comenzi încorporate. Iar dicționarul limbajului de programare este definit, deci este mai puțin flexibil decât omul. Prin urmare, trebuie, de obicei, să adăugăm cuvintele dvs. pentru a evita repetițiile inutile.

Definiția funcției

Definiția funcției este definiția obișnuită a unei variabile în care valoarea variabilei este funcțională. De exemplu, următorul cod determină variabila pătrată, care se referă la o funcție care contează pătratul numărului specificat:

Var Square \u003d funcția (x) (retur x * x;); Consola.log (pătrat (12)); // → 144.

Funcția este creată printr-o expresie care începe cu funcția de cuvinte cheie. Funcțiile au un set de parametri (în acest caz, numai x) și organismul care conține instrucțiunile care trebuie executate atunci când funcția este apelată. Corpul funcției se încheie întotdeauna în paranteze curbate, chiar dacă acesta constă dintr-o singură instrucțiune.

Funcția poate avea mai mulți parametri sau nici măcar nu poate fi. În exemplul următor, MakeNoise nu are o listă de parametri, iar puterea are două dintre ele:

Var Makenoise \u003d Funcție () (Console.log ("Vine!");); A face zgomot (); // → șiffs! VAR POWER \u003d FUNCTION (BASE, EXPONENT) (VAR Rezultatul \u003d 1, pentru (VAR Count \u003d 0; Count< exponent; count++) result *= base; return result; }; console.log(power(2, 10)); // → 1024

Unele funcții revin o valoare cum ar fi puterea și pătratul, altele nu se întorc ca makenoise, ceea ce face doar un efect secundar. Instrucțiunea de întoarcere definește valoarea returnată de funcție. Când procesarea programului vine la această instrucțiune, acesta iese imediat din funcție și returnează această valoare în locația codului în care a fost apela funcția. Întoarcerea fără expresie returnează valoarea nedefinită.

Parametri și domeniul de aplicare

Parametrii funcției sunt aceleași variabile, dar valorile inițiale sunt setate atunci când funcția este apelată și nu în codul său.

O proprietate importantă a caracteristicilor este că variabilele create în cadrul funcției (inclusiv parametrii) sunt locale în interiorul acestei funcții. Aceasta înseamnă că, în exemplul cu putere, variabila de rezultate va fi creată de fiecare dată când funcția este apelată, iar aceste încarnări individuale nu sunt conectate între ele.

Această localitate variabilă se aplică numai parametrilor și creată în interiorul funcțiilor variabilelor. Variabilele specificate în afara oricărei funcții sunt numite globale, deoarece acestea sunt vizibile pe tot parcursul programului. Puteți accesa astfel de variabile în funcție, cu excepția cazului în care ați declarat o variabilă locală cu același nume.

Următorul cod ilustrează-l. Acesta determină și cauzează două funcții care atribuie valoarea variabilei x. Primul anunță-l ca pe unul local, schimbând astfel numai variabila locală. Al doilea nu declară, astfel încât să lucrați cu x în interiorul funcției se referă la variabila globală X specificată la începutul exemplului.

Var x \u003d "exterior"; var f1 \u003d funcția () (var x \u003d "în interiorul F1";); F1 (); Consola.log (x); // → în afara varf f2 \u003d funcția () (x \u003d "în interiorul F2";); F2 (); Consola.log (x); // → în interiorul F2

Un astfel de comportament ajută la prevenirea interacțiunii accidentale între funcții. Dacă toate variabilele au fost utilizate oriunde în program, ar fi foarte dificil să se asigure că o variabilă nu este utilizată în diferite scopuri. Și dacă ați folosit din nou variabila, ați întâmpina efecte ciudate atunci când codul terț va strica valorile variabilei dvs. Referindu-se la local pentru funcțiile variabilei, astfel încât acestea să existe numai în interiorul funcției, limbajul face posibilă lucrul cu funcții ca și cum ar fi cu un univers mic, care vă permite să nu vă faceți griji cu privire la întregul cod.

Zone imbricate de aspect

JavaScript distinge nu numai variabilele globale și locale. Funcțiile pot fi setate în interiorul funcțiilor, ceea ce duce la mai multe niveluri de localitate.

De exemplu, următoarea funcție destul de lipsită de sens conține în încă două:

Var Landscape \u003d Funcție () (rezultatul Var \u003d ", Var plat \u003d Funcția (dimensiunea) (pentru (VAR Count \u003d 0; Count< size; count++) result += "_"; }; var mountain = function(size) { result += "/"; for (var count = 0; count < size; count++) result += """; result += "\\"; }; flat(3); mountain(4); flat(6); mountain(1); flat(1); return result; }; console.log(landscape()); // → ___/""""\______/"\_

Funcțiile plane și montane văd variabila rezultatului deoarece se află în interiorul funcției în care este definită. Dar ele nu pot vedea variabilele de numărare reciproc, deoarece variabilele unei singure funcții sunt în afara scopului celuilalt. Iar înconjurarea exterioară a funcției peisajului nu vede nici una dintre variabilele definite în interiorul acestei funcții.

Pe scurt, în fiecare zonă locală de vizibilitate puteți vedea toate zonele care o conțin. Un set de variabile disponibile în interiorul funcției este determinat de locul în care această funcție este descrisă în program. Toate variabilele din blocurile din jurul definiției funcției sunt vizibile - inclusiv cele care sunt definite la nivelul superior din programul principal. Această abordare a zonelor de vizibilitate se numește lexical.

Persoanele care au studiat alte limbi de programare pot crede că orice bloc închis în paranteze curbate își creează mediul local. Dar în JavaScript, domeniul de vizibilitate creează numai funcții. Puteți utiliza blocuri separate:

VaS ceva \u003d 1; (VaC ceva \u003d 2; // face ceva cu variabila ceva ...) // ieși din bloc ...

Dar ceva în interiorul blocului este aceeași variabilă ca și în exterior. Deși astfel de blocuri sunt permise, este logic să le folosiți numai pentru comanda IF și Cycles.

Dacă vă pare ciudat - pare nu numai pentru dvs. În JavaScript 1.7, a apărut cuvântul cheie, care funcționează ca var, dar creează variabile, locale pentru orice unitate dată și nu doar pentru funcția.

Funcționează ca valori

Numele funcțiilor sunt de obicei utilizate ca nume pentru o bucată de program. O astfel de variabilă o dată setată și nu se schimbă. Deci, este ușor să confundăm funcția și numele său.

Dar este două lucruri diferite. Apelul funcției poate fi utilizat ca o variabilă simplă - de exemplu, pentru a le folosi în orice expresie. Este posibilă stocarea unei funcții într-o variabilă nouă, transmiteți-o ca parametru al unei alte funcții și așa mai departe. De asemenea, stocarea variabilă a apelului funcției rămâne o variabilă convențională, iar valoarea sa poate fi modificată:

VAR Launchistiile \u003d funcția (valoarea) (MissiiSystem.Lanch ("PLI!");); dacă (Safemode) Launchistiile \u003d funcție (valoare) (/ * fub * /);

În capitolul 5, vom discuta lucruri minunate care pot fi făcute prin transmiterea apelurilor apelurilor către alte funcții.

Anunțarea funcțiilor

Există o versiune mai scurtă a expresiei "Var Square \u003d funcția ...". Cuvântul cheie al funcției poate fi utilizat la începutul instrucțiunilor:

Funcție pătrată (x) (retur x * x;)

Aceasta este o funcție de anunțuri. Instrucțiunea definește variabila pătrată și o atribuie o funcție dată. În timp ce totul este în regulă. Există o singură piatră subacvatică în această definiție.

Consola.log ("viitorul spune:", viitorul ()); Funcția viitorului () (return "încă nu avem mașini zburatoare";)

Astfel de coduri de cod, deși funcția este declarată sub codul care îl utilizează. Acest lucru se întâmplă deoarece declarațiile de funcții nu fac parte din execuția obișnuită a programelor de sus în jos. Acestea sunt "mutate" până la vârful domeniului lor de aplicare și pot fi cauzate în orice cod din acest domeniu. Uneori este convenabil deoarece puteți scrie codul în această ordine care arată cel mai inteligent fără a vă îngrijora necesitatea de a determina toate funcțiile deasupra locului unde sunt utilizate.

Și ce se va întâmpla dacă punem declarația funcției în interiorul blocului sau ciclului condițional? Nu face aia. Din punct de vedere istoric, diferite platforme pentru rularea JavaScript au tratat astfel de cazuri în moduri diferite, iar standardul limbilor actual îl interzice. Dacă doriți ca programele dvs. să funcționeze în serie, utilizați caracteristicile funcțiilor numai în alte funcții sau în programul principal.

Exemplul funcției () (funcția A () () // normul dacă (ceva) (funcția b () () // ai-yai-yai!)

Stivă de apeluri

Utile se va uita la modul în care funcționează comanda de execuție cu funcții. Iată un program simplu cu mai multe caracteristici:

Funcție salută ("consola.log (" hi, "+ who);) salut (" sperma "); Consola.log ("poek");

Acesta este procesat aproximativ astfel: apelul salut face ca pasajul să pornească funcția. Aceasta determină funcția consola încorporată, care interceptează controlul, își face treaba și returnează controlul. Apoi vine la sfârșitul salutului și se întoarce la locul unde a fost chemat. Următoarea linie numește din nou consola.

Schematic, poate fi reprezentat astfel:

Top consola de salut.log salut consola de sus.log top

Deoarece funcția ar trebui să se întoarcă la locul în care a fost numit, calculatorul trebuie să-și amintească contextul din care a fost apelat funcția. Într-un caz, consola.log ar trebui să se întoarcă la salut. În cealaltă, se întoarce la sfârșitul programului.

Un loc în care computerul își amintește contextul se numește stivă. De fiecare dată când apelați o funcție, contextul actual este amplasat la etajul la etaj. Când funcția se întoarce, este nevoie de contextul superior din stivă și îl folosește pentru a continua.

Stocarea de stocare necesită loc în memorie. Când stiva se sparge prea mult, calculatorul oprește execuția și dă ceva de genul "Stack deverflow" sau "prea multă recursură". Următorul cod îl arată - acesta stabilește computerul o întrebare foarte dificilă, ceea ce duce la salturi infinite între două funcții. Mai precis, ar fi salturi nesfârșite dacă computerul avea un stivă nesfârșită. În realitate, stiva este revărsată.

Funcție de pui () (Return Ou ()) Funcție ouă () (Pui de întoarcere ();) Console.log (pui () + "a venit primul"); // → ??

Argumente opționale

Următorul cod este permis și efectuat fără probleme:

Alertă ("Bună ziua", "Bună seara", "Bună ziua tuturor!");

Oficial, funcția ia un argument. Cu toate acestea, cu un astfel de apel, nu se plânge. Ea ignoră restul argumentelor și arată "salut".

JavaScript este foarte loial cu privire la numărul de argumente transmise funcții. Dacă treceți prea mult, nu va fi ignorat inutil. Prea puțin - lipsa va fi atribuită nedefinită.

Minusul acestei abordări este că este posibil - și chiar probabil - de a transfera funcțiile unui număr greșit de argumente și nimeni nu se va plânge de asta.

Plus faptul că puteți crea funcții care acceptă argumente opționale. De exemplu, în următoarea versiune a funcției de putere, aceasta poate fi cauzată de două și cu un argument, - în ultimul caz al expozantului va fi doi, iar funcția funcționează ca un pătrat.

Funcție de alimentare (bază, exponent) (dacă (Exponent \u003d\u003d Undefined) Exponent \u003d 2; Var Rezult \u003d 1; pentru (VAR Count \u003d 0; Count< exponent; count++) result *= base; return result; } console.log(power(4)); // → 16 console.log(power(4, 3)); // → 64

În capitolul următor, vom vedea cum în corpul funcției puteți afla numărul exact de argumente transferate la acesta. Acest lucru este util, pentru că Vă permite să creați o funcție care acceptă orice număr de argumente. De exemplu, consola.log folosește această proprietate și afișează toate argumentele transferate:

Consola.log ("r", 2, "d", 2); // → R 2 d 2

Închidere

Abilitatea de a utiliza apelurile de funcții ca variabile cu faptul că variabilele locale de fiecare dată când funcția este numită din nou, ne conduce la o întrebare interesantă. Ce se întâmplă cu variabilele locale atunci când funcția nu mai funcționează?

Următorul exemplu ilustrează această întrebare. Acesta declară funcția wrapvalue, care creează o variabilă locală. Apoi returnează o funcție care citește această variabilă locală și returnează valoarea acestuia.

Funcție wrapvalueble \u003d n; funcția de retur ();) var wrap1 \u003d wrapvalue (1); Var Wrap2 \u003d WrapValue (2); Consola.log (wrap1 ()); // → 1 consola.log (wrap2 ()); // → 2.

Este permisă și funcționează așa cum ar trebui - accesul la rămășițele variabile. În plus, în același timp pot exista mai multe cazuri de aceeași variabilă care confirmă încă o dată faptul că, cu fiecare funcție de apel, variabilele locale sunt recreate.

Această caracteristică de lucru cu referire la o anumită instanță a unei variabile locale se numește închidere. Funcția de închidere a variabilelor locale se numește închidere. Nu numai că vă eliberează de îngrijorările legate de viața variabilelor, dar vă permite, de asemenea, să creați o funcție creativă.

Cu o ușoară schimbare, vom transforma exemplul nostru într-o funcție care multiplică numerele la orice număr dat.

Multiplion function (numărul de retur * factor;);) var de două ori \u003d multiplicator (2); Consola.log (de două ori (5)); // → 10.

O variabilă separată, cum ar fi localizată dintr-un exemplu cu wrapvalue nu mai este necesară. Deoarece parametrul este variabila locală în sine.

Practica va trebui să înceapă să gândească într-un mod similar. O versiune bună a modelului mental este de a reprezenta faptul că funcția îngheață codul în corpul său și îl împrăștie în pachet. Când vedeți funcția de returnare (...) (...), imaginați-vă că aceasta este o bucată de panou de control, înghețată pentru utilizare ulterioară.

În exemplul nostru, multiplicatorul returnează o bucată de cod înghețată pe care o salvăm în variabila de două ori. Ultima linie determină o funcție închisă într-o variabilă, în legătură cu care este activată codul salvat (numărul de retur *). El are încă acces la variabila factorului, care a fost determinată la numirea multiplicatorului, în plus, are acces la argumentul transmis în timpul dezghețului (5) ca parametru numeric.

Recursură

Funcția poate provoca el însuși dacă îi pasă de a nu depăși stiva. Această funcție se numește recursivă. Iată un exemplu de implementare alternativă a exercițiului în gradul:

Funcție de alimentare (bază, exponent) (dacă (exponent \u003d\u003d 0) retur 1; altceva de întoarcere * putere (bază, exponent - 1); consolă (putere (2, 3)); // → 8.

Aproximativ, așa că matematica determină exercițiul și, poate, descrie conceptul mai elegant decât ciclul. Funcția se determină de mai multe ori cu diferite argumente pentru a obține multiplicarea multiplă.

Cu toate acestea, această implementare are o problemă - în mediul obișnuit JavaScript este de 10 ori mai lent decât versiunea cu un ciclu. Trecerea peste ciclu este mai ieftină decât apelul funcției.

Dilema "Viteza împotriva eleganței" este destul de interesantă. Există unele decalaje între confortul pentru o persoană și comoditate pentru mașină. Orice program poate fi accelerat, făcându-l mai mult și mai complicat. Programatorul necesită un bilanț adecvat.

În cazul primei erecții, ciclul non-delegant este destul de simplu și de înțeles. Nu are sens să-i înlocuiască recursiunea. Adesea, însă, programele funcționează cu astfel de concepte complexe pe care doriți să le reduceți eficiența prin îmbunătățirea lizibilității.

Regula principală care sa repetat de mai multe ori și cu care sunt pe deplin de acord - nu vă faceți griji cu privire la viteza în timp ce nu sunteți sigur că programul încetinește. Dacă da, găsiți acele părți care lucrează mai mult decât toată lumea și schimbă eleganța acolo cu eficiență.

Desigur, nu ar trebui să ignorăm imediat viteza. În multe cazuri, ca și în cazul construirii unei simplități speciale a soluțiilor elegante, nu primim. Uneori, un programator experimentat vede imediat că o abordare simplă nu va fi niciodată suficient de rapidă.

Mă concentrez asupra acestei atenții, deoarece prea mulți programatori de novice sunt suficienți pentru eficiență chiar și în trifle. Rezultatul este mai mult, mai dificil și adesea nu fără erori. Astfel de programe vor scrie mai mult și funcționează adesea mult mai repede.

Dar recursiunea nu este întotdeauna doar o alternativă mai puțin eficientă la cicluri. Unele sarcini sunt mai ușor de rezolvat recursiunea. Cel mai adesea se ocupă de mai multe ramuri ale unui copac, fiecare dintre acestea se poate filia.

Aici este un mister: puteți obține un număr infinit de numere, începând cu numerele 1, și apoi adăugând 5 sau multiplicând de 3. Cum scriem o funcție care, după ce a primit un număr, încearcă să găsească o secvență de Astfel de construcții și multiplicări care duc la un număr dat? De exemplu, numărul 13 poate fi obținut, mai întâi multiplicând de la 1 la 3 și apoi adăugând 5 de două ori. Iar numărul 15 nu poate fi obținut.

Soluție recursivă:

Funcție Findsolution (țintă) (start \u003d\u003d țintă) Istoric de întoarcere; altcineva dacă (pornire\u003e țintă) return null; altceva retur găsi (Start + 5, "(" + istorie + "+ 5)") || Găsire (Start * 3, "(" + istorie + "* 3)");) retur găsiți (1, "1");) consolă.log (Findsolution (24)); // → ((1 * 3) + 5) * 3)

Acest exemplu nu găsește neapărat cea mai scurtă soluție - este mulțumită de orice. Nu mă aștept să înțelegi imediat modul în care funcționează programul. Dar să înțelegem acest exercițiu excelent pentru gândirea recursivă.

Funcția internă de găsire este angajată în recursură. Este nevoie de două argumente - numărul actual și șirul care conține înregistrarea modului în care am ajuns la acest număr. Și returnează fie o linie care prezintă secvența de pași, fie nulă.

Pentru aceasta, funcția îndeplinește una dintre cele trei acțiuni. Dacă numărul specificat este ținta, atunci istoricul actual este doar o metodă de realizare, deci se întoarce. Dacă numărul specificat este mai mare decât obiectivul, nu există niciun sens să continuați multiplicarea și adăugarea, deoarece va crește doar. Și dacă nu am ajuns încă la țintă, funcția încearcă ambele căi posibile pornind de la un număr dat. Ea se numește de două ori, o dată cu fiecare fel. Dacă primul apel returnează nul, se întoarce. Într-un alt caz, al doilea este returnat.

Pentru a înțelege mai bine modul în care funcția atinge efectul dorit, să navigați provocările care apar în căutarea soluției pentru numărul 13.

Găsiți (1, "1") Găsiți (6, "(1 + 5)") Găsiți (11, "(1 + 5) + 5)") Găsiți (16, "((1 + 5) + 5 ) + 5) ") Găsire prea mare (33" ((1 + 5) + 5) * 3) ") Găsire prea mare (18" ((1 + 5) * 3) ") Găsire prea mare ( 3, "(1 * 3)") Găsiți (8, "((1 * 3) + 5)") Găsiți (13 "((1 * 3) + 5) + 5)") găsite!

O liniuță arată adâncimea stivei de provocare. Pentru prima dată, funcția de găsire se determină de două ori pentru a verifica soluțiile începând cu (1 + 5) și (1 * 3). Primul apel este în căutarea unei soluții începând cu (1 + 5), iar cu ajutorul recursului verifică toate deciziile care emite un număr mai mic sau egal cu cel dorit. Nu găsește și returnează nul. Apoi operatorul || și continuă să apeleze o funcție care explorează opțiunea (1 * 3). Aici așteptăm noroc, pentru că în al treilea apel recursiv primim 13. Acest apel returnează un șir și fiecare dintre operatori || Pe parcurs, transmite această linie de mai sus, ca rezultat, decizia de returnare.

Creștem funcții

Există două modalități mai mult sau mai puțin naturale de a introduce funcții în program.

În primul rând - scrieți un cod similar de mai multe ori. Acest lucru ar trebui evitat - mai mult cod înseamnă mai mult spațiu pentru erori și mai mult material pentru citirea celor care încearcă să înțeleagă programul. Deci, luăm o funcționalitate repetitivă, o luăm un nume bun și o punem într-o funcție.

A doua cale - detectați nevoia unei noi funcționalități, care este demnă de cameră într-o funcție separată. Începeți cu numele funcției și apoi scrieți corpul ei. Puteți începe chiar cu codul de scriere care utilizează funcția înainte ca funcția în sine să fie definită.

Cât de greu de ales un nume pentru o funcție, arată cât de bine vă imaginați funcționalitatea acestuia. Ia un exemplu. Trebuie să scriem un program cu două numere, numărul de vaci și puii de găină, urmată de cuvintele "vaci" și "pui". La numerele trebuie să adauge zerouri, astfel încât fiecare să ocupă exact trei poziții.

007 Vaci 011 Pui

Evident, avem nevoie de o funcție cu două argumente. Începem să mergem.
// Funcție PrintFarmErmenTector (vaci, găini) (vaci); în timp ce (Cowstring.Length< 3) cowString = "0" + cowString; console.log(cowString + " Коров"); var chickenString = String(chickens); while (chickenString.length < 3) chickenString = "0" + chickenString; console.log(chickenString + " Куриц"); } printFarmInventory(7, 11);

Dacă adăugăm la șir, vom obține lungimea. Se pare că ciclurile se adaugă zerouri din față la numere până când primesc o linie în 3 caractere.

Gata! Dar numai ne-am adunat pentru a trimite un cod agricultor (împreună cu o verificare corectă), el cheamă și ne spune că porcii au apărut în fermă și am putea adăuga numărul de porci la program?

Desigur, este posibil. Dar când începem copierea și introducerea codului din aceste patru linii, înțelegem că trebuie să vă opriți și să vă gândiți. Trebuie să existe o modalitate mai bună. Încercăm să îmbunătățim programul:

// Funcția de presiune a calculatorului Funcție PrintzePaddedWithLABEL (număr, etichetă) (numberstring \u003d șir (număr); în timp ce (numblength.length< 3) numberString = "0" + numberString; console.log(numberString + " " + label); } // вывестиИнвентаризациюФермы function printFarmInventory(cows, chickens, pigs) { printZeroPaddedWithLabel(cows, "Коров"); printZeroPaddedWithLabel(chickens, "Куриц"); printZeroPaddedWithLabel(pigs, "Свиней"); } printFarmInventory(7, 11, 3);

Lucrări! Dar numele printzeopadddedWithalBel este un pic cam ciudat. Combină trei lucruri - ieșirea, adăugând zerouri și eticheta - într-o singură funcție. În loc să introduceți întregul fragment repetat în funcție, să evidențiem un concept:

// Adăugați la funcția ZEROPAD (număr, lățime) (Var String \u003d șir (număr); în timp ce (string.Length< width) string = "0" + string; return string; } // вывестиИнвентаризациюФермы function printFarmInventory(cows, chickens, pigs) { console.log(zeroPad(cows, 3) + " Коров"); console.log(zeroPad(chickens, 3) + " Куриц"); console.log(zeroPad(pigs, 3) + " Свиней"); } printFarmInventory(7, 16, 3);

O funcție cu un nume bine, ușor de înțeles ZEROPAD facilitează înțelegerea codului. Și poate fi folosit în multe situații, nu numai în cazul nostru. De exemplu, pentru a scoate tabelele formatate cu numere.

Cât de inteligent și versatil trebuie să fie funcții? Putem scrie atât cea mai simplă funcție care completează numărul cu zerouri la trei poziții și funcția de încredere a scopului general de a forma numerele care susțin fracțiunile, numerele negative, alinierea prin puncte, adăugarea la diferite simboluri etc.

Regulă bună - Adăugați numai funcționalitatea care este tocmai utilă pentru dvs. Uneori există o tentație de a crea cadre de numire generală pentru fiecare nevoie mică. Rezista lui. Nu terminați niciodată să lucrați, ci doar să scrieți o grămadă de cod pe care nimeni nu o va folosi.

Funcții și efecte secundare

Funcțiile pot fi împărțite aproximativ în cele care sunt cauzate de efectele lor secundare și cele care sunt chemate să obțină o anumită valoare. Desigur, este posibil să se combine aceste proprietăți într-o singură funcție.

Prima funcție auxiliară în exemplul cu ferma, imprimareroperipaddedwithlabel, se numește datorită efectului secundar: Afișează un șir. În al doilea rând, ZEROPAD, datorită valorii returnate. Și aceasta nu este o coincidență faptul că a doua funcție este mai des și mai des. Funcțiile pe care valorile de returnare sunt mai ușor de combinat între ele decât cu funcțiile care creează efecte secundare.

Funcția netă este un tip special de funcții care returnează o valoare care nu numai că nu are efecte secundare, dar nu depinde de efectele secundare ale restului codului - de exemplu, nu funcționează cu variabile globale care ar putea fi accidental sa schimbat în altă parte. Funcția curată, fiind cauzată de aceleași argumente, returnează același rezultat (și nimic mai mult) - care este destul de frumos. Cu ea doar munca ei. Apelarea unei astfel de funcții poate înlocui mental rezultatul lucrării sale, fără a schimba semnificația codului. Când doriți să verificați această caracteristică, puteți să-l apelați și să vă asigurați că dacă funcționează în acest context, acesta va funcționa în orice caz. Nu astfel de funcții pure pot returna rezultate diferite în funcție de mai mulți factori și să aibă efecte secundare dificil de verificat și de luat în considerare.

Cu toate acestea, nu este necesar să fii timid să nu scrieți funcții destul de curate sau să începeți curățarea sacră a codului de la astfel de funcții. Efectele secundare sunt adesea utile. Nu există nici o modalitate de a scrie o versiune curată a funcției Console.Log, iar această caracteristică este foarte utilă. Unele operațiuni sunt mai ușor de exprimat prin utilizarea efectelor secundare.

Rezultat

Acest capitol vă arată cum să vă scrieți propriile funcții. Când cuvântul cheie funcției este utilizat ca expresie, returnează un indicator la un apel de funcții. Când este folosit ca instrucțiune, puteți declara o variabilă prin atribuirea unui apel funcțional.

Punctul cheie în înțelegerea funcțiilor este zonele de vizibilitate locală. Parametrii și variabilele declarate în interiorul funcției, locale pentru acesta sunt re-selectate de fiecare dată când se numește și nu este vizibil afară. Funcțiile declarate în cadrul unei alte funcții au acces la domeniul său de aplicare.

Este foarte util să separăm diferite sarcini efectuate de program în funcție de funcție. Nu trebuie să repetați, funcțiile fac ca codul să fie mai lizibil, împărțind-o în părți semantice, precum și capetele și secțiunile de ajutor pentru organizarea textului obișnuit.

Exerciții

Minim

În capitolul precedent, funcția Math.min a fost menționată, returnând cele mai mici argumente. Acum putem scrie o astfel de funcție. Scrieți o caracteristică min care ia două argumente și returnând cel minim.

Consola.log (min (0, 10)); // → 6 console.log (min (0, -10)); // → -10.

Recursură

Am văzut că operatorul% (echilibrul diviziei) poate fi utilizat pentru a determina dacă numărul (% 2) poate fi determinat. Și aici este o altă modalitate de a determina:

Zero.
Unitatea este ciudată.
Orice număr N este același cu N-2.

Scrieți funcția recursivă ISEVEN în conformitate cu aceste reguli. Ar trebui să ia un număr și să returneze semnificația booleană.

Testați-l la 50 și 75. Încercați să îl setați -1. De ce se comportă în acest fel? Este posibil să o rezolvăm într-un fel?

Testați-l la 50 și 75. A se vedea cum se comportă pe -1. De ce? Te poți gândi la o modalitate de a rezolva asta?

Consola.log (Isen (50)); // → True Console.Log (ISEVEN (75)); // → Console false.log (ISEVEN (-1)); // → ??

Considerăm fasolea.

Simbolul N numere poate fi obținut prin adăugarea la IT.charat (N) ("cusături" .charat (5)) - similar cu primirea lungimii șirului cu. Lungime. Valoarea returnă va fi un șir compus dintr-un singur simbol (de exemplu, "k"). La primul șir de caractere, poziția 0, ceea ce înseamnă că ultimul personaj va fi poziția de șir lungime - 1. Cu alte cuvinte, șirul de două caractere 2, și pozițiile sale vor fi 0 și 1.

Scrieți caracteristica numărătoare care ia șirul ca argument și returnează numărul de caractere "B" conținute în rând.

Apoi, scrieți caracteristica numărătoare care funcționează aproximativ așa cum Număctele acceptă doar al doilea parametru - caracterul pe care îl vom fi semnat în șir (în loc să citiți pur și simplu numărul de caractere "B"). Pentru a face acest lucru, remikeați caracteristica numărătoare.

Operatori de tranziție și procesare de excepție

O altă categorie de operatori de limbă JavaScript sunt operatorii de tranziție. După cum urmează numele, acești operatori fac ca interpretul JavaScript să meargă într-un alt loc în codul programului. Operatorul de pauză determină interpretul să meargă la sfârșitul ciclului sau alte instrucțiuni. Operatorul Continue determină interpretul să renunțe la partea rămasă a corpului ciclului, să se întoarcă la începutul ciclului și să procedeze la executarea noii iterații. În JavaScript, este posibil să marcați instrucțiunile cu numele, astfel încât în \u200b\u200bpauză și să continuați operatorii, puteți indica în mod explicit ce ciclu sau la ce alte instrucțiuni se referă.

Declarația de întoarcere determină ca interpret să se deplaseze din funcția apelată înapoi la punctul de apel și să returneze valoarea apelului. Operatorul de aruncare excită excepția și este proiectat să funcționeze în combinație cu operatorii de încercare / captură / în cele din urmă, care definesc blocul de cod software pentru a procesa excepția. Aceasta este o varietate destul de complicată de operatori de tranziție: când apare o excepție, interpretul avansează la cel mai apropiat manipulator de excepție cuprinzător, care poate fi în aceeași funcție sau mai mare, în stiva de rambursare a funcției numită.

Mai mulți dintre acești operatori de tranziție sunt descriși în următoarele subsecțiuni.

Etichete de instrucțiuni

Orice instrucțiune poate fi marcată de identificatorul și colonul specificat în fața acesteia:

identificator: Instrucțiune

Instrucțiuni de marcare, vrei să spui să-i dai un nume, care poate fi folosit ca o legătură oriunde în program. Puteți marca orice instrucțiune, totuși, are sens numai instrucțiuni având un corp, cum ar fi cicluri și instrucțiuni condiționate.

Având atribuirea numelui ciclului, atunci poate fi utilizat în ruperea și continuarea instrucțiunilor, în interiorul ciclului pentru a ieși sau pentru a merge la începutul ciclului, la următoarea iterație. Instrucțiunile de întrerupere și continuare sunt singurele instrucțiuni din limba JavaScript, în care puteți specifica etichetele - acestea sunt descrise mai detaliat mai jos. Mai jos este un exemplu de etichetare a instrucțiunilor în timp ce instrucțiunile Continuare utilizând această etichetă:

MainLOOOOOOOOOOOOOOOOOOOOA: In timp ce (// null) (// cod software a omis ... Continuați Mainoop; // Tranziția la următoarea iterație a ciclului numit)

Identificatorul utilizat ca etichetă a instrucțiunii poate fi orice identificator JavaScript admisibil, cu excepția cuvântului rezervat. Numele etichetelor sunt separate de numele variabilelor și funcțiilor, astfel încât identificatorii care corespund numelor variabilelor sau funcțiilor sunt permise ca etichete.

Etichetele instrucțiunilor sunt definite numai în cadrul instrucțiunilor la care se aplică (și, bineînțeles, în interiorul instrucțiunilor investite în ele). Instrucțiunile inveduse nu pot fi marcate de aceiași identificatori deoarece instrucțiunile îi însoțesc, dar două instrucțiuni independente pot fi etichetate cu aceleași etichete. Instrucțiunile marcate pot fi reutilizate. Adică, orice instrucțiune poate avea multe etichete.

Pauza operatorului

Operatorul de pauză duce la ieșirea imediată din ciclul intern sau la operatorul de comutare. Anterior, am văzut deja exemple de utilizare a operatorului de spargere în interiorul operatorului de comutare. În cicluri, acesta este utilizat în mod obișnuit pentru ieșirea imediată din ciclu atunci când din orice motiv este necesar să completați execuția ciclului.

Când ciclul are o condiție complexă de completare, este adesea mai ușor să realizați aceste condiții folosind operatorul de pauză decât să încercați să le exprimați într-o expresie convențională a ciclului. Următorul exemplu încearcă să găsească un element de matrice cu o anumită valoare. Ciclul este completat în mod obișnuit pentru a ajunge la sfârșitul matricei sau pentru a utiliza operatorul de pauză de îndată ce se găsește valoarea dorită:

Var arr \u003d ["a", "b", "in", "g", "d"], rezultat; pentru (var i \u003d 0; i

În limba JavaScript, este permisă specificarea numelui etichetei pentru spargerea cuvintelor cheie (identificator fără colon):

pauză name_name;

Când operatorul de pauză este utilizat cu o etichetă, acesta efectuează trecerea la sfârșitul instrucțiunii numite sau la încetarea executării acestuia. În absența instrucțiunilor cu încercarea specificată, încercarea de a utiliza o astfel de formator de pauză generează o eroare sintactică. Instrucțiunea numită nu este obligată să fie un ciclu sau un operator de comutare. Operatorul de pauză cu o etichetă poate efectua "ieșire" din orice instrucțiuni care îl însoțește. Instrucțiunea cuprinzătoare poate fi chiar un bloc simplu de instrucțiuni închise numai în paranteze curbate, pentru a-l marca.

Între pauza de cuvinte cheie și numele etichetei nu este permisă introducerea simbolului de traducere a liniei. Faptul este că interpretul JavaScript masorează automat virgulele pierdute: Dacă împărțiți bara de cod program între pauza de cuvinte cheie și eticheta de lângă acesta, interpretul sugerează că există o formă simplă a acestui operator fără o etichetă și adăugați a punct şi virgulă.

Operatorul de pauză cu o etichetă este necesar numai atunci când este necesar să întrerupeți execuția instrucțiunii care nu este cel mai apropiat ciclu de tensiune sau operatorul de comutare.

Continuați operatorul

Operatorul Continue este similar cu operatorul de pauză. Cu toate acestea, în loc să ieșiți din ciclu, operatorul Continue lansează o nouă iterație de ciclu. Sintaxa Continue operator este la fel de simplă ca și sintaxa operatorului de întrerupere. Operatorul Continue poate fi, de asemenea, utilizat cu o etichetă.

Operatorul Continue, atât în \u200b\u200bformă de neetichetă, cât și etichetă, poate fi utilizat numai în corpul ciclului. Folosirea acestuia în alte locuri duce la o eroare sintactică. Când se efectuează operatorul Continue, repetarea actuală a ciclului este întreruptă și începe următoarele. Pentru diferite tipuri de cicluri, acest lucru înseamnă altfel:

În timpul ciclului, expresia indicată la începutul ciclului este verificată din nou și, dacă este adevărat, corpul ciclului este efectuat de la început.

În ciclu, în timp, există o tranziție la capătul ciclului, unde condiția este verificată din nou înainte de re-executarea ciclului.

În ciclu, se calculează expresia incrementării și expresia de scanare este din nou calculată pentru a determina dacă trebuie efectuată următoarea iterație.

În ciclul FOR / IN, ciclul începe din nou cu atribuirea numelui variabil specificat al următoarei proprietăți.

Acordați atenție diferențelor în comportamentul operatorului Continue în timp și pentru cicluri. Ciclul în timp ce se întoarce direct la starea sa, iar ciclul pentru mai întâi calculează expresia incrementării și apoi revine la starea. Următorul exemplu arată utilizarea operatorului Continue fără o etichetă pentru a ieși din iterația curentă a ciclului pentru numerele chiar:

Var sum \u003d 0; // Calculați suma nu numerelor nici măcar de la 0 - 10 pentru (var i \u003d 0; i

Operatorul Continue, cum ar fi pauza, poate fi utilizat în cicluri imbricate într-o formă care include o etichetă, iar apoi un ciclu nou început nu va fi neapărat un ciclu care conține direct operatorul Continue. În plus, în ceea ce privește pauza, traducerile rândului între cuvântul cheie continuă și numele etichetelor nu sunt permise.

Returnarea operatorului

Apelul funcției este o expresie și ca toate expresiile contează. Operatorul de retur din interiorul funcțiilor este utilizat pentru a determina valoarea returnată de funcție. Operatorul de returnare poate fi localizat numai în funcția corpului. Prezența acestuia în orice alt loc este o eroare sintactică. Când se efectuează declarația de retur, funcția returnează valoarea programului de apelare. De exemplu:

Dacă funcția nu are instrucțiunea de retur, când se numește, interpretul va executa instrucțiuni în funcția funcției unul după altul până când ajunge la sfârșitul funcției și apoi va returna controlul programului său. În acest caz, expresia apelului va reveni undefined. Declarația de întoarcere este adesea ultima instrucțiune din funcție, dar este complet opțională: funcția va returna controlul programului de apelare de îndată ce este atinsă declarația de retur, chiar dacă au urmat alte instrucțiuni din funcția corpului.

Operatorul de returnare poate fi, de asemenea, utilizat fără o expresie, apoi întrerupe pur și simplu executarea funcției și returnează valoarea nedefinită de programul de apelare. De exemplu:

Funcția myfun (arr) (// dacă o matrice conține dereglementări. Numere, întrerupeți funcția Fe (var i \u003d 0; i

Aruncați operatorul

O exceptie - Acesta este un semnal care indică orice excepție sau eroare. Excitație excepțională (aruncare) - Aceasta este o modalitate de a semna despre o astfel de eroare sau o situație exclusivă. Prindeți excepția (captura) - înseamnă să o procesați, adică Luați măsuri necesare sau potrivite pentru recuperare după excepție.

În JavaScript, excepțiile sunt încântate în cazurile în care apare eroarea de timp de execuție și când programul o excită în mod explicit folosind operatorul aruncat. Excepțiile sunt interceptate folosind încercarea / captura / în cele din urmă operatorii, care sunt descrise mai târziu.

Operatorul de aruncare are următoarea sintaxă:

aruncați expresia;

Rezultatul expresiei poate fi valoarea oricărui tip. Operatorul de aruncare poate fi transferat într-un număr reprezentând un cod de eroare sau un șir care conține textul mesajului de eroare. Interpretul JavaScript excită excepția utilizând o instanță de clasă Eroare Una dintre subclasele sale și puteți folosi și o abordare similară. Obiectul de eroare are o proprietate nume.Definirea tipului de eroare și a proprietății mesajconținând un șir transmis la funcția de proiectare. Următorul este un exemplu de funcție care excită obiectul de eroare atunci când sunați la un argument nevalid:

// Funcția funcției funcției Factorial (Număr) (// Dacă argumentul de intrare nu este o valoare validă, // Excepție este excitat! Dacă (numărul 1; i * \u003d numărul, numărul -); / * corpul ciclului gol * / Retur I;) consola.log ("5! \u003d", Factorial (5)); consola.log ("- 3! \u003d", Factorial (-3));

Atunci când o excepție este încântată, interpretul JavaScript întrerupe imediat executarea normală a programului și se desfășoară la cel mai apropiat manipulator de excepție. În ceea ce privește manipulorii de excepție, se utilizează operatorul de captură de încercare / captură / în cele din urmă, care este descris în următoarea secțiune.

Dacă blocul de cod de program în care a apărut o excepție nu are designul de captură corespunzător, interpretul analizează următorul bloc de cod software extern și verifică dacă dispozitivul de funcționare a excepției este asociat cu acesta. Aceasta continuă până se găsește manipulatorul.

Dacă excepția este generată într-o funcție care nu conține încercarea / captura / în cele din urmă proiectarea, care este destinată procesului, atunci excepțiile se aplică mai mari la codul programului care a cauzat funcția. Astfel, excepțiile se aplică structurii lexicale a metodelor JavaScript până la stiva de apeluri. Dacă nu se găsește un manipulator de excepție, excepția este considerată o eroare și este raportată utilizatorului.

Încercați / capturați / în cele din urmă designul

Încercarea / capturarea / în cele din urmă designul implementează mecanismul de excepție în JavaScript. Încercați operatorul Acest design definește pur și simplu un bloc de cod în care sunt procesate excepții. În spatele încercării, urmează unitatea operatorul de captură Cu instrucțiunile care sunt numite dacă undeva în unitatea de încercare apare o excepție. Operatorul de captură urmează blocul in cele din urma.cuprinzând un cod de program care execută operațiunile finale garantate pentru a fi efectuate indiferent de ceea ce se întâmplă în unitatea de încercare.

Și blocul de captură, iar blocul în cele din urmă nu este obligatoriu, dar după ce unitatea de încercare trebuie să fie cel puțin una dintre ele. Încercarea, capturarea și în cele din urmă blochează încep și se termină în paranteze curbate. Aceasta este o parte obligatorie a sintaxei și nu poate fi omisă, chiar dacă o singură instrucțiune conține între ele.

Următorul fragment ilustrează sintaxa și scopul încercării / designului de captură / în cele din urmă:

Încercați (// În mod obișnuit, acest cod fără eșecuri funcționează de la început până la sfârșit. // Dar, la un moment dat poate fi generată printr-o excepție // sau direct utilizând instrucțiunea de aruncare sau indirect - // apelul o metodă care generează o excepție. ) Catch (EX) (// Instrucțiunile din acest bloc sunt efectuate numai atunci când TRA // este o excepție. Aceste instrucțiuni pot utiliza variabila locală ex, // se referă la obiectul de eroare sau la o altă valoare specificată în instrucțiunea de aruncare. . , // ce sa întâmplat în unitatea de încercare. Ele sunt executate dacă blocul de încercare sa încheiat: // 1) ca de obicei, ajungând la sfârșitul blocului // 2) datorită pauzei, continuați sau returnării operatorilor // 3) cu excepția prelucrată În blocul de captură de peste // 4) cu o excepție impregnată care își continuă distribuția la niveluri mai înalte)

Rețineți că cheia de captură ar trebui să fie identificator în paranteze. Acest identificator este similar cu parametrul funcției. Atunci când o excepție este interceptată, o excepție va fi atribuită acestui parametru (de exemplu, obiectul de eroare). Spre deosebire de identificatorul variabil obișnuit asociat operatorului de captură, există numai în corpul blocului de captură.

Următorul este un exemplu mai realist de încercare de încercare / captură. Cauzează metoda factorială () definită în exemplul anterior, iar metodele Prompt () și Alertă () Client JavaScript pentru a organiza intrarea și ieșirea:

Încercați (// solicitați un număr de la utilizator var n \u003d număr (prompt ("introduceți un număr pozitiv", "")); // calculați factorialul numerelor, presupunând, // că datele de intrare sunt corecte VAR F \u003d Factorial (N); // eliminați alerta de rezultat (N + "! \u003d" + F);) captura (ex) (// dacă datele sunt incorecte, controlul va fi transmis aici Alert (ex); T. Informați utilizatorul despre eroare)

Dacă utilizatorul intră într-un număr negativ, va fi afișat un mesaj de avertizare:

Acesta este un exemplu de design de încercare / captură fără un operator în cele din urmă. Deși în cele din urmă este folosit nu la fel de des ca captura, totuși, acest operator este uneori util. Blocul în cele din urmă este garantat pentru a fi executat dacă se execută cel puțin o parte a unității de încercare, indiferent de modul în care codul programului este finalizat în unitatea de încercare. Această caracteristică este de obicei utilizată pentru a executa operațiunile finale după efectuarea codului programului în continuarea încercării.

Într-o situație normală, Oficiul ajunge la sfârșitul unității de încercare și apoi trece la blocul în cele din urmă, care efectuează operațiunile finale necesare. Dacă controlul a ieșit din unitatea de încercare ca urmare a executării returnării, continuarea sau întreruperea declarațiilor, înainte de a trece controlul într-un alt loc, se efectuează blocul final.

Dacă apare o excepție în unitatea de încercare și există un bloc de captură adecvat pentru procesarea acestuia, controlul este transmis mai întâi la blocul de captură și apoi în blocul în cele din urmă. Dacă nu există bloc de captură locală, atunci controlul este transmis mai întâi la blocul în cele din urmă și apoi merge la cel mai apropiat bloc de captură extern, care poate procesa o excepție.

Dacă unitatea Finall în sine transmite controlul utilizând returnarea, continuați, întrerupeți sau aruncați declarații sau prin apelarea unei metode care generează o excepție, comanda neterminată la controlul transmiterii este anulată și este nouă. De exemplu, dacă blocul în cele din urmă generează o excepție, această excepție va înlocui orice excepție generată anterior.

Operator Întoarcere.completează execuția funcției curente și returnează valoarea acestuia.

Codul sursă al acestui exemplu interactiv este stocat în depozitul de pe GitHub. Dacă doriți să participați la proiectul de exemple interactive, vă rugăm să blocați https://github.com/mdn/interactive-examples

Sintaxă

Retur [[expresie]]; Expresia expresiei a cărui valoare va fi returnată. Cu excepția cazului în care este indicat, nedefinit este returnat în schimb.

Descriere

Când sunați la declarația de retur în funcție, execuția sa se oprește. Valoarea specificată este returnată în locația funcției. De exemplu, funcția de mai jos returnează valoarea argumentului său ridicat la pătrat (unde x este numărul):

Funcție pătrată (x) (retur x * x;) var demo \u003d pătrat (3); // valoarea demo va fi 9

Dacă valoarea returnată nu este specificată, se observă undefined în schimb.

Următoarele expresii întrerup întotdeauna funcția:

Întoarcere; Întoarce-te adevărat; Întoarce-te fals; Retur x; Retur x + y / 3;

Plasarea automată a punctelor cu virgule

Funcția Magic (x) (funcția de retur Calc (x) (retur x * 42);) var răspuns \u003d magie (); Răspuns (1337); // 56154.

Specificații

Specificație	stare	cometariu
Ecmasrcript Prima ediție (ECMA-262)	Standard	Definiție inițială
ECMAScript 5.1 (ECMA-262)	Standard
ECMAScript 2015 (ediția a 6-a, ECMA-262) Definiție "Declarație de întoarcere" în această specificație.	Standard
ECMAScript ultimul proiect (ECMA-262) Definiție "Declarație de întoarcere" în această specificație.	Proiect

Compatibilitate cu browserele

Tabelul de compatibilitate de pe această pagină este generat de datele structurate. Dacă doriți să contribuiți la date, vă rugăm să le luați din depozitul https://github.com/mdn/browser-compat-data și trimiteți-ne o solicitare pentru a vă permite modificările.

Actualizați datele de compatibilitate pe GitHub

	Calculatoare						Mobil						Server
	Crom.	Margine.	Firefox.	Internet Explorer.	Operă.	Safari.	Android WebView.	Chrome pentru Android.	Firefox pentru Android.	Opera pentru Android.	Safari pe iOS.	Samsung Internet.	Nod.js.
Întoarcere.	Crom. Suport complet 1	Margine. Suport complet 12	Firefox. Suport complet 1	Adică Suport complet 3	Operă. Suport complet da	Safari. Suport complet da	WebView Android. Suport complet 1	Chrome Android. Suport complet 18	Firefox Android. Suport complet 4	Opera Android Suport complet da	Safari ios. Suport complet da	Samsung Internet Android Suport complet 1.0	nodejs. Suport complet da

Funcțiile sunt una dintre cele mai importante blocuri de clădiri ale codului din JavaScript.

Funcțiile constau dintr-un set de comenzi și, de obicei, efectuează o anumită sarcină (de exemplu, sumarea numerelor, calculul rădăcinii etc.).

Codul plasat în funcție va fi efectuat numai după apelul în mod explicit la această funcție.

Anunțarea funcțiilor

1. Sintaxă:

// anunțarea funcției funcției funcției (PER1, PER2) (codul funcției) // Apelarea funcției funcției de caracteristică (PER1, PER2);

2. Sintaxă:

// Anunțarea funcției Nume funcționale VAR \u003d funcție (PER1, PER2) (codul funcției) // Apelarea funcției funcției de caracteristică (PER1, PER2);

funcția de nume Specifică numele funcției. Fiecare funcție de pe pagină trebuie să aibă un nume unic. Numele funcției trebuie să fie setat de litere latine și nu trebuie să înceapă cu numerele.

per1. și per2. sunt variabile sau valori care pot fi trecute în interiorul funcției. În fiecare funcție, poate fi transmis un număr nelimitat de variabile.

Notă: Chiar dacă variabilele nu sunt transmise funcției, nu uitați să introduceți paranteze rotunde "() după numele funcției.

Notă: Numele funcțiilor din JavaScript sunt sensibile la registru.

Exemplu de funcții JavaScript.

Funcția MessageWrite () din exemplul de mai jos va fi efectuată numai după apăsarea butonului.

Notă: Acest exemplu utilizează un eveniment onClick. Evenimentele JavaScript vor fi discutate în detaliu mai târziu în acest manual.

Transmiterea funcțiilor variabile

Puteți transmite variabile nelimitate la funcții.

Notă: Toate manipulările deasupra variabilelor din interiorul funcțiilor nu sunt de fapt peste variabilele în sine și peste copia lor, prin urmare conținutul variabilei în sine ca rezultat al funcțiilor nu este schimbat.

/ * Setați funcția care adaugă la variabila transmisă 10 și afișează rezultatul la pagina * / funcția Plus (A + 10; document.write ("ieșire de funcții:" + A + "
");) var a \u003d 25; document.write (" valoare variabilă înainte de funcția de apel: "+ A +"
");
");

Vizualizare rapidă

Pentru a accesa variabila globală din funcție, mai degrabă decât utilizarea copiilor sale fereastră.

Funcție plus (a) (fereastră.a \u003d a + 10;) var a \u003d 25; document.write ("valoarea variabilei înainte de funcția funcției:" + A + "
"); Plus (a); document.write (" valoare variabilă după apelarea unei funcții: "+ A +"
");

Vizualizare rapidă

Echipa de returnare

Cu ajutorul echipei Întoarcere. Puteți reveni la funcțiile valorii.

Vizualizare rapidă

Funcții încorporate

În plus față de funcțiile definite de utilizator în JavaScript, există și caracteristici încorporate.

De exemplu, funcția încorporată isfinită. Vă permite să verificați dacă numărul transmis transmis.

Document.write (isfinit (40) + "
"); Document.write (isfinit (-590) +"
"); Document.write (izfinit (90.33) +"
"); document.write (izfinit (nan) +"
"); document.write (izfinit (" este un șir ") +"
");

Vizualizare rapidă

Notă: Puteți găsi o listă completă de funcții JavaScript încorporate în noastre.

Variabilele locale și globale

Variabilele create în interiorul funcțiilor sunt numite variabile locale. Vă puteți referi la astfel de variabile numai în interiorul funcțiilor în care au fost definite.

După finalizarea executării codului funcției, astfel de variabile sunt distruse. Aceasta înseamnă că variabilele cu același nume pot fi definite în diferite funcții.

Variabilele create în afara codului funcțiilor sunt numite variabile globale Pentru astfel de variabile, puteți contacta orice cod de locație.

Dacă declarați o variabilă fără VAR în interiorul funcției, ea devine, de asemenea, globală.

Variabilele globale sunt distruse numai după închiderea paginii.

Vizualizare rapidă

Notă: Când afișați variabila var2 va fi goală, deoarece Func1 funcționează cu variabila variabilă locală.

Utilizați funcții anonime

Funcțiile care nu conțin nume atunci când se declară declararea anonim.

Funcțiile anonime sunt declarate în principal pentru apelul ulterior din cod ca funcții convenționale, ci pentru a transfera alte funcții ca parametru.

ARRMAP FUNCȚIONAL (ARR, FUNC) (VAR RES \u003d matrice nouă; pentru (var i \u003d 0; i ");

Vizualizare rapidă

Fa-te

Exercitiul 1. Erori corecte în codul de mai jos:

Exercitiul 1

Corectați eroarea din cod.

Sarcina 2..

1. Redați codul funcției 1-3 după revizuirea comportamentului acestora atunci când transmiteți parametri diferiți.
2. Determinați cuvântul cheie care interacționează cu funcția 4.

Sarcina 2.

// apelați primul document de funcții secrete.Write (SECFUNCN1 (4.12) + "
"); // apelați al doilea document de funcții secrete.Write (SECFUNCN2 (100.10) +"
"); // provocarea celei de-a treia funcție secretă SECFUNCN3 (23.10); document.write ("
"); // provocarea celei de-a patra funcții secrete SECFUNC4 (" p ");

Porniți JavaScript pentru a utiliza comentariul DISQUC.