funktioner

ofte er vi nødt til at udføre en lignende handling på mange steder i scriptet.

for eksempel skal vi vise en flot besked, når en besøgende logger ind, logger ud og måske et andet sted.

funktioner er de vigtigste “byggesten” af programmet. De tillader koden at blive kaldt mange gange uden gentagelse.

Vi har allerede set eksempler på indbyggede funktioner, f.eks. alert(message) prompt(message, default) og confirm(question). Men vi kan også skabe vores egne funktioner.,

funktion Erklæring

for at oprette en funktion kan vi bruge en funktion erklæring.

Det ser ud som dette:

function showMessage() { alert( 'Hello everyone!' );}

function søgeord går først, derefter går navnet på den funktion, derefter en liste af parametre mellem de parenteser (komma-separeret, tomme i eksemplet ovenfor) og endelig koden for funktionen, også kaldet “den funktion krop”, mellem krøllede parenteser.,

function name(parameters) { ...body...}

Vores nye funktion kan kaldes ved sit navn: showMessage().

For eksempel:

function showMessage() { alert( 'Hello everyone!' );}showMessage();showMessage();

call showMessage() udfører koden for funktionen. Her ser vi beskeden to gange.

dette eksempel viser tydeligt et af hovedmålene med funktioner: at undgå kodeduplikation.,

hvis vi nogensinde har brug for at ændre meddelelsen eller den måde, den vises på, er det nok at ændre koden et sted: den funktion, der udsender den.

lokale variabler

en variabel erklæret inde i en funktion er kun synlig inde i denne funktion.

For eksempel:

ydre variabler

en funktion kan også få adgang til en ydre variabel, for eksempel:

let userName = 'John';function showMessage() { let message = 'Hello, ' + userName; alert(message);}showMessage(); // Hello, John

funktionen har fuld adgang til den ydre variabel. Det kan ændre det så godt.,

For eksempel:

den ydre variabel bruges kun, hvis der ikke er nogen lokal variabel.

Hvis en samme navngivne variabel er erklæret inde i funktionen, skygger den den ydre. For eksempel bruger funktionen i koden nedenfor den lokale userName. Den ydre ignoreres:

parametre

Vi kan overføre vilkårlige data til funktioner ved hjælp af parametre (også kaldet Funktionsargumenter) .

I eksemplet nedenfor, funktionen har to parametre: from og text.,

Når funktionen kaldes i linjer (*) og (**), den givne værdier er kopieret til den lokale variabler from og text. Derefter bruger funktionen dem.

Her er endnu et eksempel: Vi har en variabel from og sender den til funktionen., Bemærk: funktionen ændringer from, men ændringen er ikke set udenfor, fordi en funktion altid får en kopi af den værdi:

Default-værdier

Hvis en parameter ikke er angivet, så er dens værdi bliver undefined.

For eksempel, den førnævnte funktion showMessage(from, text) kan kaldes med et enkelt argument:

showMessage("Ann");

Det er ikke en fejl. Et sådant opkald ville udsende "*Ann*: undefined"., Der er ingen text, så det antages, at text === undefined.,

Hvis vi ønsker at bruge en “standard” text i dette tilfælde, så vi kan angive det efter =:

function showMessage(from, text = "no text given") { alert( from + ": " + text );}showMessage("Ann"); // Ann: no text given

hvis Nu text parameter er ikke bestået, det vil få værdi "no text given"

Her "no text given" er en streng, men det kan være et mere komplekst udtryk, som kun er vurderet og tildelt, hvis parameter mangler., Så dette er også muligt:

Alternative standardparametre

Nogle gange giver det mening at indstille standardværdier for parametre ikke i funktionserklæringen, men på et senere tidspunkt under dens udførelse.,parameter, vi kan sammenligne det med undefined:

function showMessage(text) { if (text === undefined) { text = 'empty message'; } alert(text);}showMessage(); // empty message

…Eller vi kunne bruge || operatør:

// if text parameter is omitted or "" is passed, set it to 'empty'function showMessage(text) { text = text || 'empty'; ...}

Moderne JavaScript-motorer støtte nullish sammensmeltende operatør ??, det er bedre, når falsy værdier, som f.eks. 0, anses for normale:

Returnerer en værdi

En funktion, der kan returnere en værdi tilbage til den kaldende kode som resultat.,

Den enkleste eksempel kunne være en funktion, der summer to værdier:

function sum(a, b) { return a + b;}let result = sum(1, 2);alert( result ); // 3

direktiv return kan være i ethvert sted i funktion. Når udførelsen når den, stopper funktionen, og værdien returneres til opkaldskoden (tildelt result ovenfor).

der kan være mange forekomster af return i en enkelt funktion. For eksempel:

det er muligt at bruge return uden en værdi., That causes the function to exit immediately.

For example:

function showMovie(age) { if ( !checkAge(age) ) { return; } alert( "Showing you the movie" ); // (*) // ...}

In the code above, if checkAge(age) returns false, then showMovie won’t proceed to the alert.,

return (some + long + expression + or + whatever * f(a) + f(b))

return; (some + long + expression + or + whatever * f(a) + f(b))

return ( some + long + expression + or + whatever * f(a) + f(b) )

navngivning af en funktion

funktioner er handlinger. Så deres navn er normalt et verb. Det skal være kort, så præcist som muligt og beskrive, hvad funktionen gør, så en person, der læser koden, får en indikation af, hvad funktionen gør.,

det er en udbredt praksis at starte en funktion med et verbalt præfiks, der vagt beskriver handlingen. Der skal være en aftale i holdet om betydningen af præfikserne.

for eksempel viser funktioner, der starter med "show" normalt noget.

funktion startende med…

eksempler på sådanne navne:

med præfikser på plads giver et blik på et funktionsnavn en forståelse af, hvilken slags arbejde det gør, og hvilken slags værdi det returnerer.,

funktioner == Kommentarer

funktioner skal være korte og gøre nøjagtigt en ting., Hvis den ting er stor, er det måske værd at opdele funktionen i et par mindre funktioner. Nogle gange kan det ikke være så let at følge denne regel, men det er bestemt en god ting.

en separat funktion er ikke kun lettere at teste og debug – dens eksistens er en god kommentar!

Sammenlign for eksempel de to funktionershowPrimes(n) nedenfor. Hver udsender primtal op til n.,

Den første variant bruger en label:

function showPrimes(n) { nextPrime: for (let i = 2; i < n; i++) { for (let j = 2; j < i; j++) { if (i % j == 0) continue nextPrime; } alert( i ); // a prime }}

Den anden variant bruger en ekstra funktion isPrime(n) for at teste, om oprindelighed:

Den anden variant er lettere at forstå, er det ikke? I stedet for kodestykket ser vi et navn på handlingen (isPrime). Nogle gange henviser folk til en sådan kode som selvbeskrivende.

Så funktioner kan oprettes, selvom vi ikke har til hensigt at genbruge dem. De strukturerer koden og gør den læsbar.,

Oversigt

En funktion erklæring, der ligner dette:

function name(parameters, delimited, by, comma) { /* code */}

• Værdier overføres til en funktion som parametre, der er kopieret til den lokale variabler.
• en funktion kan få adgang til ydre variabler. Men det virker kun indefra og ud. Koden uden for funktionen ser ikke dens lokale variabler.
• en funktion kan returnere en værdi. Hvis det ikke gør det, er resultatet undefined.,

for at gøre koden ren og let at forstå, anbefales det at bruge hovedsageligt lokale variabler og parametre i funktionen, ikke ydre variabler.

det er altid lettere at forstå en funktion, der får parametre, arbejder med dem og returnerer et resultat end en funktion, der ikke får nogen parametre, men ændrer ydre variabler som en bivirkning.

funktion navngivning:

• et navn skal klart beskrive, hvad funktionen gør. Når vi ser et funktionskald i koden, giver et godt navn os øjeblikkeligt en forståelse af, hvad det gør og vender tilbage.,
• en funktion er en handling, så funktionsnavne er normalt verbale.
• Der findes mange kendte funktion præfikser som create… show… get… check… og så videre. Brug dem til at antyde, hvad en funktion gør.

funktioner er de vigtigste byggesten i scripts. Nu har vi dækket det grundlæggende, så vi faktisk kan begynde at oprette og bruge dem. Men det er kun begyndelsen på stien. Vi vil vende tilbage til dem mange gange og gå dybere ind i deres avancerede funktioner.