Javascript-funktion suorittaminen uudella tavalla. Funktioiden ylikuormitus JavaScriptissä. JavaScript-funktion kutsuminen
JavaScript-koodia voidaan ajaa useilla tavoilla - ulkoisesta tiedostosta, sivun yläosassa olevasta tekstikappaleesta ja suoraan käsittelijältä HTML-tapahtumat elementti. Tarkastellaan kaikkia näitä menetelmiä yksityiskohtaisemmin.
Ulkoinen koodiEnsimmäinen ja suositeltava vaihtoehto on kirjoittaa koodi sisään ulkoinen tiedosto(.js-tunnisteella), joka voidaan sisällyttää verkkosivullemme käyttämällä HTML-tunnistetta ja määrittämällä tiedoston sijainnin src-attribuutilla. JavaScriptin saatavuus erillinen tiedosto vähentää koodin päällekkäisyyttä, jos käytät sitä uudelleen toisella sivulla. Näin selain voi myös tallentaa tiedoston välimuistiin etäasiakkaan tietokoneeseen, mikä lyhentää sivun latausaikaa.
Upotettu koodi
Toinen vaihtoehto on upottaa koodi suoraan verkkosivulle. Tämä saavutetaan myös käyttämällä HTML-tageja, mutta sen sijaan, että tiedosto määritettäisiin src-attribuutissa, koodi sijoitetaan tagien väliin. Vaikka joissakin tapauksissa on asianmukaista käyttää tätä vaihtoehtoa, useimmissa tapauksissa on parasta tallentaa koodimme ulkoiseen tiedostoon yllä kuvatulla tavalla.
hälytys("Hei maailma!");
AttribuutitViimeinen vaihtoehto on käyttää tapahtumakäsittelijän attribuutteja HTML-elementtejä. Tätä menetelmää ei ehdottomasti suositella:
Esimerkki
Klikkaa Minä!
Klikkaa Minä myös!
Kokeile itse » Sijainti
Kahden edellisen vaihtoehdon sijoitus on tärkeä ja voi vaihdella tilanteen mukaan. Jos sisällytät JavaScriptin, joka ei käytä sivun elementtejä, on turvallista sijoittaa komentosarja ennen HTML-tunnistetta. Jos koodisi on kuitenkin vuorovaikutuksessa sivun elementtien kanssa, sinun on varmistettava, että kyseiset elementit ovat jo olemassa komentosarjan suoritushetkellä. Tätä yleistä virhettä voidaan havainnollistaa alla olevalla esimerkillä. Skripti elementin löytämiseksi, jonka tunnus on hello-world, suoritetaan ennen kuin elementti määritellään dokumentissa.
Esimerkki
// Yritetään käyttää elementtiä liian aikaisin
johtaa arvaamattomiin tuloksiin.
var otsikko = document.getElementById("hello-world");
console.log(title);
Hei maailma
Pääsy on sijoittaa käsikirjoitukset sivun loppuun ennen finaalia HTML-tunniste. Tämä varmistaa, että elementit on jo määritetty, kun komentosarja suoritetaan.
Julkaisupäivä: 15.5.2013
Kirjoita jotain Java kieli ei ole niin yksinkertainen, ja ilman perustietoja et todennäköisesti pysty tekemään sitä. Jos kuitenkin pidit jostain tällä kielellä kirjoitetusta sovelluksesta, voit ladata sen ja asentaa sen verkkosivustollesi. Voit päättää, mitä se palvelee, ehkä se houkuttelee käyttäjiä, ehkä se vain koristaa tai ehkä se suorittaa joitain toimintoja. Oletetaan, että latasit sen nyt eniten pääkysymys, kuinka ajaa JS-skripti. Tässä artikkelissa yritämme vastata tähän kysymykseen.
Jotta voit muodostaa yhteyden Javascripiin, sinulla on oltava pääsy yksinkertainen html sivun koodi. Yksi kaikista yksinkertaisia tapoja– kirjoita komento tunnisteeseen missä tahansa sivun sisällä.
Kuinka liittää komentosarja mihin tahansa sivustoon?
Java-skriptin näyttämisprosessi alkaa siitä hetkestä, kun selain näyttää html-sivusi. Kun se havaitsee tunnisteen, se alkaa avata kaikkea siihen kirjoitettua ja suorittaa sen koodia. Samalla selain jatkaa kaiken sivun materiaalin avaamista.
SISÄÄN tässä esimerkissä Näytämme kuinka selain suorittaa hälytystoiminnon kolme kertaa, ja vasta tämän komennon suorittamisen jälkeen se näyttää loput.
01
02
03 Kanien laskeminen
04
05
06 for(var i=1; i undefined alert(typeof window.makeArray); // => funktio
Eli kutsutaan makeArray("one", "two"); vastaa kutsumista window.makeArray("one", "two"); .
Minua harmittaa, että tämä on yleisin tapa kutsua toimintoja, koska se edellyttää globaalin funktion läsnäoloa. Ja me kaikki tiedämme sen globaaleja toimintoja ja muuttujat eivät ole ohjelmoinnin paras muoto. Tämä pätee erityisesti JavaScriptiin. Vältä globaaleja määritelmiä, etkä tule katumaan sitä.
Funktioiden kutsumissääntö #1: Jos funktiota kutsutaan suoraan, objektia määrittelemättä (esimerkiksi myFunction()), tämän arvo on globaali objekti (ikkuna, jos koodi suoritetaan selaimessa).
Menetelmän kutsuminen Luodaan yksinkertainen objekti ja tehdään makeArray sen menetelmäksi. Ilmoitamme objektin käyttämällä kirjaimellista merkintää ja kutsumme sitten menetelmäämme:// luo objekti var arrayMaker = ( someProperty: "joku arvo", make: makeArray ); // kutsua make()-metodia arrayMaker.make("one", "two"); // => [ arrayMaker, "one", "two" ] // vaihtoehtoinen syntaksi, käytä hakasulkeita arrayMaker["make"]("yksi", "kaksi"); // => [ arrayMaker, "yksi", "kaksi" ]
Näetkö eron? Tämän arvo tässä tapauksessa on itse objekti. Miksi ei ikkunaa, kuten edellisessä tapauksessa, koska funktion määrittely ei ole muuttunut? Salaisuus on, kuinka funktiot välitetään JavaScriptissä. Toiminto on vakio JavaScript-tyyppi, joka on itse asiassa objekti, ja kuten kaikki muutkin objektit, toimintoja voidaan välittää ja kopioida. SISÄÄN tässä tapauksessa, kopioimme olennaisesti koko funktion, mukaan lukien argumenttiluettelon ja rungon, ja määritimme tuloksena olevan objektin arrayMaker-objektin make-ominaisuuteen. Tämä vastaa tällaista julistusta:
var arrayMaker = ( someProperty: "Joku arvo"; make: function (arg1, arg2) ( return [ this, arg1, arg2]; ) );
Funktion kutsusääntö #2: Metodikutsun syntaksilla kutsutussa funktiossa, kuten obj.myFunction() tai obj["myFunction"]() , tällä on arvo obj .
Tämän yleisesti yksinkertaisen periaatteen väärinymmärtäminen johtaa usein virheisiin tapahtumien käsittelyssä:
toimintopainikeClicked())( var text = (tämä === ikkuna) ? "ikkuna" : this.id; hälytys(teksti); ) var button1 = document.getElementById("btn1"); var button2 = document.getElementById("btn2"); button1.onclick = painikettaKlikkattiin; button2.onclick = toiminto())( painikettaKlikkattiin(); );
Ensimmäisen painikkeen napsauttaminen näyttää viestin "btn1" koska tässä tapauksessa kutsumme funktiota menetelmänä, ja tämä funktion sisällä saa sen objektin arvon, johon tämä menetelmä kuuluu. Napsauta toista painiketta "ikkuna" koska tässä tapauksessa kutsumme buttonClicked suoraan (eli ei kuten obj.buttonClicked()). Sama asia tapahtuu, kun määritämme tapahtumakäsittelijän elementtitunnisteeseen, kuten kolmannen painikkeen tapauksessa. Kolmannen painikkeen napsauttaminen näyttää saman viestin kuin toinen.
Kun käytät kirjastoja, kuten jQuery, sinun ei tarvitse ajatella tätä. jQuery kirjoittaa tämän arvon uudelleen tapahtumakäsittelijässä siten, että tämä arvo on elementti, joka nosti tapahtuman:
// käytä jQueryä $("#btn1").click(function() ( alert(this.id); // jQuery varmistaa, että "this" on painike ));
Kuinka jQuery onnistuu muuttamaan tämän arvoa? Lue alla.
var auto = ( vuosi: 2008, malli: "Dodge Bailout" ); makeArray.apply(auto, [ "yksi", "kaksi" ]); // => [ auto, "yksi", "kaksi" ] makeArray.call(auto, "yksi", "kaksi"); // => [ auto, "yksi", "kaksi" ]
Nämä kaksi menetelmää ovat hyvin samankaltaisia. Ensimmäinen parametri ohittaa tämän. Niiden väliset erot ovat seuraavissa argumenteissa: Function.apply() hyväksyy joukon arvoja, jotka välitetään funktiolle, kun taas Function.call() hyväksyy argumentit erikseen. Käytännössä mielestäni on kätevämpää käyttää apply() .
Funktion kutsusääntö #3: Jos haluat ohittaa tämän arvon kopioimatta funktiota toiseen objektiin, voit käyttää myFunction.apply(obj) tai myFunction.call(obj) .
Rakentajat En mene yksityiskohtiin mukautettujen tyyppien määrittämisestä JavaScriptissä, mutta mielestäni on välttämätöntä muistuttaa, että JavaScriptissä ei ole luokkia ja kaikki mukautetut tyypit tarvitsevat rakentajan. Lisäksi menetelmät mukautettu tyyppi On parempi ilmoittaa se käyttämällä prototyyppiä, joka on konstruktorifunktion ominaisuus. Luodaan oma tyyppimme:// ilmoittaa konstruktorifunktio ArrayMaker(arg1, arg2) ( this.someProperty = "ei väliä"; this.theArray = [ this, arg1, arg2 ]; ) // ilmoittaa menetelmät ArrayMaker.prototype = ( someMethod: function () ( alert( "Jokin menetelmä kutsuu" getArray: function () ( return this.theArray; ) ); var am = new ArrayMaker("yksi", "kaksi"); var other = new ArrayMaker("ensimmäinen", "toinen"); am.getArray(); // => [ am, "yksi", "kaksi" ]
Tässä esimerkissä tärkeä asia on uuden operaattorin läsnäolo ennen funktiokutsua. Jos sitä ei olisi, se olisi globaali kutsu, ja konstruktorissa luodut ominaisuudet kuuluisivat globaaliin objektiin. Emme tarvitse sitä. Lisäksi rakentajat eivät yleensä palauta arvoja eksplisiittisesti. Ilman uutta operaattoria konstruktori palauttaisi undefined , sen kanssa se palauttaa tämän . Sitä pidetään hyvänä tyylinä nimetä rakentajia iso kirjain; Tämä muistuttaa sinua uuden operaattorin tarpeesta.
Muussa tapauksessa rakentajan sisällä oleva koodi on todennäköisesti samanlainen kuin koodi, jonka kirjoittaisit toisella kielellä. Tämän merkitys tässä tapauksessa on uusi kohde, jonka luot.
Funktion kutsusääntö #4: Kun funktiota kutsutaan uudella operaattorilla, tämän arvo on uusi JavaScript-ajonaikaisen objektin luoma objekti. Jos tämä funktio ei palauta mitään objektia eksplisiittisesti, tämä palautetaan implisiittisesti.
Johtopäätös Toivottavasti ymmärrät eron eri tavoilla funktiokutsujen avulla voit parantaa JavaScript-koodiasi. Joskus tähän arvoon liittyviä virheitä on vaikea havaita, joten on järkevää estää ne etukäteen.Artikkeli kehitteillä!
Artikkeli, jossa pohditaan, mikä funktio on, sekä perinteinen (klassinen) versio sen kanssa työskentelystä. Lisäksi analysoidaan mitkä ovat funktion ja return-operaattorin argumentit (parametrit).
Mikä on funktio?Funktio on joukko ohjeita, joille voidaan antaa nimi ja jota voidaan sitten käyttää sillä nimellä mistä tahansa ohjelmasta.
Klassinen esimerkki funktion käytöstä. Verkkosivulla on JavaScript-koodi, jokin fragmentti, jossa toistetaan useita kertoja. Tämän välttämiseksi voit muotoilla tämän fragmentin funktiona ja kutsua sen sitten sisään oikeissa paikoissa koodi tämän funktion nimellä. Tämän toiminnon kutsuminen tarkoittaa sen sisältämien ohjeiden suorittamista.
Kuinka järjestää jonkin tehtävän suorittaminen JavaScriptissä funktioiden avulla? Voit tehdä tämän tavallisesti seuraavasti:
- jakaa tehtävä sen osiin (alitehtäviin);
- osatehtävät formalisoidaan funktioiden kautta;
- kehittää pääkoodi kutsumalla luotuihin funktioihin.
Tämän seurauksena tällaisesta ohjelmasta tulee jäsennellympi. Erilaisten muutosten tekeminen ja uusien ominaisuuksien lisääminen on helpompaa.
Toiminnon ilmoittaminen ja kutsuminenToiminnot JavaScriptin funktiolla voidaan jakaa kahteen vaiheeseen:
- funktion ilmoittaminen (luominen).
- kutsua (suorita) tämä toiminto.
Toiminnan ilmoitus. Funktion luominen JavaScriptissä alkaa kirjoittamisesta avainsana funktio , sitten ilmoitetaan funktion nimi, sitten parametrit luetellaan tarvittaessa suluissa x, jonka jälkeen ilmoitetaan ohjeet, jotka on liitetty henkselit.
// funktion määritys someName function someName() ( alert("Soitit funktion someName!"); ) JavaScript - Funktiomäärittelyn syntaksi
Tällaisia JavaScriptin funktioita kutsutaan funktion määrityslauseiksi. Tämän tyypin lisäksi JavaScript erottaa myös toimintoja funktion määritelmä lauseke ja nuolifunktio lauseke .
Toiminnon nimi muodostetaan samojen sääntöjen mukaan kuin muuttujan nimi. Nuo. se voi sisältää kirjaimia, numeroita (0-9), "$" ja "_" merkkejä. On suositeltavaa käyttää vain kirjaimia kirjaimina Englannin aakkoset(a-z, A-Z). Funktion nimi, kuten muuttujan nimi, ei voi alkaa numerolla.
Funktiolla voi olla niin monta parametria kuin halutaan tai ei ollenkaan. Sulkumerkit sisältyvät joka tapauksessa. Jos parametreja on useita, ne on erotettava pilkulla. Toimintoparametreihin päästään niiden nimellä.
Aaltosulkeisiin suljettu käskysarja on toimintokoodi, joka suoritetaan, kun sitä kutsutaan.
Toimintokutsu. Ilmoitettua toimintoa itsessään ei suoriteta. Jotta se voidaan suorittaa, se on kutsuttava. Funktiota kutsutaan määrittämällä sen nimi ja kaksi sulkumerkkiä. Argumentit määritellään tarvittaessa suluissa.
// kutsuu edellisessä esimerkissä annettua funktiota someName(); JavaScript - Funktiokutsun syntaksi 
JavaScriptin funktiot ovat objekteja. JavaScriptissä kaikki on objektia paitsi kuusi primitiivistä tietotyyppiä. Ja jos funktio on objekti, niin viittaus siihen voidaan tallentaa muuttujaan.
// funktion määritys someName function someName() ( alert("Kutsuit funktiota someName!"); ) var reference = someName;
Tämän jälkeen voit kutsua funktiota seuraavasti:
Viite();
Funktioiden parametrit ja argumentitFunktioargumentit ovat arvoja, jotka välitetään funktiolle, kun sitä kutsutaan. Argumentit erotetaan toisistaan pilkulla.
// kutsua sayWelcome-funktiota välittämällä sille kaksi argumenttia sayWelcome("Ivan", "Ivanov"); // toinen kutsu sayWelcome-funktiolle kahdella argumentilla sayWelcome("Peter", "Petrov");
Funktioparametrit ovat yksi JavaScriptin tavoista, joilla voit käyttää funktion argumentteja. Suluissa on kuvattu funktion parametrit sen ilmoitusvaiheessa.
Toisin sanoen funktioparametrit ovat paikallisia muuttujia, jotka luodaan automaattisesti, kun toiminto käynnistetään. Parametrit saavat arvoina vastaavat argumentit, jotka funktiolle välitetään sen kutsun aikana. Voit käyttää parametreja vain tämän funktion sisällä, niitä ei ole olemassa.
// Ilmoitus funktiosta sayWelcome, jossa on kaksi parametria funktio sayWelcome (userFirstName, userLastName) ( // ohje, joka näyttää parametrien “userFirstName” ja “userLastName” arvot konsoliin console.log("Tervetuloa, " + userLastName + " " + userFirstName ; )
JavaScriptissä funktiota kutsuttaessa argumenttien määrän ei tarvitse olla sama kuin parametrien lukumäärä. Parametrit, joita ei ole asetettu arvoon kutsuttaessa, ovat yhtä kuin määrittelemättömät.
Kutsutaan esimerkiksi funktiota yllä olevasta esimerkistä määrittämättä yhtä tai kahta parametria:
// kutsumalla sanomaWelcome-funktiota ja antamalla sille yksi argumentti sayWelcome("Peter"); // Tervetuloa, määrittelemätön Peter // kutsuu sayWelcome-funktiota välittämättä sille argumentteja sayWelcome(); // Tervetuloa, undefined undefined
Esimerkki funktiosta, joka yksinkertaisesti tulostaa sille välitetyt argumentit selainkonsoliin:
// funktion määritysfunktio outputParam(param1, param2, param3) ( console.log(param1 + "; " + param2 + "; " + param3); ) // kutsuu funktiota outputParam välittämällä sen erilaisia määriä parametrit outputParam("Rain","Lumi","Sumu"); // Sade; Lumi; Sumun lähtöParam(17); // 17; määrittelemätön; määrittelemätön lähtöParam(24,33); // 24; 33; määrittelemätön outputParam(); // määrittelemätön; määrittelemätön; määrittelemätön
Toinen tapa käyttää funktion argumentteja on käyttää erikoisargumenttiobjektia. Argumentteihin päästään argumenttien kautta samalla tavalla kuin tavallisen taulukon elementteihin, ts. niiden sarjanumeroiden perusteella. Siten argumentti - antaa sinulle mahdollisuuden saada ensimmäinen argumentti, argumentit - toinen argumentti jne.
// ilmoitus summafunktiot funktio sum(num1, num2) ( /* num1 tai argumentit – saa argumentin 1 arvon num2 tai argumentit – saa argumentin 2 arvon */ var sum1 = num1 + num2, sum2 = argumentit + argumentit; return "Saadun määrä yhdellä tavalla on " + summa1 + ", 2. menetelmällä saatu summa on " + summa2; ) /* tulostaa summafunktion tuloksen konsoliin 7 - ensimmäinen argumentti (se voidaan käyttää joko nimellä num1); tai argumenteilla) 4 - toinen argumentti (siihen pääsee joko nimellä num2 tai argumenteilla) */ console.log(sum(7,4));
Suurin ero näiden menetelmien välillä on, että ensimmäinen niistä antaa sinun käyttää vain niitä argumentteja, joille annettiin nimet funktion määritysvaiheessa. Toisen menetelmän avulla voit saada minkä tahansa argumentin arvon, vaikka sillä ei olisi nimeä (by sarjanumero). Tämä on mahdollisuus JavaScript-kieli voit luoda universaaleja joustavia toimintoja.
Argumenttien vastaanottamisen lisäksi argumenttiobjektin avulla voit myös tietää niiden lukumäärän. Tämä tehdään pituusominaisuuden avulla.
Voit iteroida funktiolle välitettyjä argumentteja esimerkiksi käyttämällä silmukalle tai ... / .
// funktion määritys summa function sum() ( var i = 0; console.log("Lähetä kaikki argumentit for-silmukalla"); 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);
Funktio, joka näyttää konsolille kaikki sille välitetyt argumentit ja niiden numeron:
// funktion määritysfunktio myFunction () ( var i; console.log("Siirrettyjen parametrien määrä = " + arguments.length); // käydään läpi kaikki parametrit for-silmukalla for (i = 0; i< arguments.length; i++) { console.log(i + " параметр = " + arguments[i]); } } // вызовы функции myFunction myFunction(3, 7, 27, "JavaScript"); myFunction(); myFunction("Яблоки", "Груши", "Апельсины");
Funktio, joka lisää kaikki sille välitetyt argumentit (niiden lukumäärää ei tiedetä etukäteen):
// funktion määritys var myCalc = function() ( // käydään läpi kaikki parametrit käyttämällä for-silmukkaa var i, sum = 0; for (i = 0; i lt; arguments.length; i++) ( summa += argumentit [i] ) // palauttaa summan tuloksena paluusummana ) // funktiokutsu (tulostus konsoliin) console.log(myCalc(4, 20, 17, -6));
Tämän seurauksena voit toteuttaa seuraavat funktion rungossa käyttämällä argumenttiobjektia:
- tarkistetaan hyväksyttyjen argumenttien määrä;
- käsitellä minkä tahansa määrän parametreja.
Itse funktion lisäksi myös muut siinä sijaitsevat funktiot pääsevät käsiksi argumentteihin, jotka sille välitetään kutsuvaiheessa.
Funktio mainF(p1, p2) ( funktio lapsiF() ( console.log("p1 = " + p1 + "; p2 = " + p2); ) childF(); ) mainF(3, 5); // p1 = 3; p2 = 5 pääF(4, 7); // p1 = 4; p2 = 7
OletusasetuksetECMAScript 2015:stä (6) alkaen toimintoparametri voidaan asettaa oletusarvoonsa.
Asetetaan esimerkiksi "color"-parametrin oletusarvo, joka on yhtä suuri kuin "#009688":
Funktio setBGColor(väri = "#009688") ( document.body.style.backgroundColor = väri; ) setBGColor(); // taustaväri on #009688 setBGColor("punainen"); // taustaväristä tulee punainen
Ennen ECMAScript 2015:tä voit asettaa parametrin oletusarvoonsa esimerkiksi näin:
Funktio setBGColor(väri) ( väri = väri !== määrittelemätön ? väri: "#009688"; // aseta väri oletusarvoon "#009688" document.body.style.backgroundColor = väri; )
Muut parametritJos funktiota kutsuttaessa annat sille enemmän argumentteja kuin sillä on parametreja, niin loput saadaan ns. rest-patametereillä. Tämä mahdollisuus ilmestyi kielellä alkaen ECMAScript 2015.
// ...nums - loput parametrit, joihin pääsee tässä tapauksessa nimellä nums-funktio doMath(mathAction, ...nums) ( var tulos = 0; nums.forEach(function(value) ( kytkin () mathAction) ( case "summa": tulos += arvo; break; tulos = 0; ) palauttaa tuloksen ) console.log(doMath("sum", 3, 4, 21, -4)); // 24 (3 + 4 + 21 + (-4)) console.log(doMath("summaneliö", 1, 4)); // 17 (1^2 + 4^2) console.log(doMath("sumCube", 3, 2, 4)); // 99 (3^3 + 2^3 + 4^3)
palautusilmoitusReturn-lause on tarkoitettu palauttamaan nykyisen funktion lausekkeen arvioinnin arvo tai tulos. Arvo tai lauseke on erotettava palautuksesta välilyönnillä. Lisäksi return-käsky pysäyttää funktion suorittamisen, ts. kaikkia sitä seuraavia ohjeita ei suoriteta.
JavaScriptin funktio palauttaa aina tuloksen riippumatta siitä, käytetäänkö return-lausetta vai ei.
// funktio, joka palauttaa tuloksen funktio sayWelcome (userFirstName, userLastName) ( if ((!userFirstName) || (!userLastName)) return "Tervetuloa, anonyymi käyttäjä"; else return "Tervetuloa, " + userLastName + " " + userFirstName ; ) // muuttujailmoitus person var person; // määritä sayWelcome-funktion tulos henkilömuuttujalle person = sayWelcome("Ivan","Ivanov"); // tulostaa muuttujan arvon konsoliin console.log(person); //Ohje, joka tulostaa konsoliin sayWelcome-funktion tuloksen console.log(sayWelcome("Petr","Petrov")); //Ohje, joka tulostaa konsoliin sayWelcome-funktion tuloksen console.log(sayWelcome("Sidorov")); JavaScript - Parametrien tarkistuksen toiminto 
JavaScriptin funktio palauttaa aina tuloksen suorituksensa seurauksena, vaikka sitä ei ole erikseen määritelty return-käskyllä. Tämä tulos on määrittelemätön.
// 1. funktio, joka ei palauta yhtään tulosta funktio sayWelcome (käyttäjäEtunimi, käyttäjäSukunimi) ( console.log("Tervetuloa, " + käyttäjäSukunimi + " " + userFirstName); ) // yritetään saada tulos funktiosta, joka ei ei palauta mitään konsoli .log(sayWelcome("Ivan", "Ivanov")); // 2. funktio, joka sisältää return-käskyn ilman arvoa funktio sayDay (day) ( päivä = "Tänään," + päivä; return; //tätä käskyä ei suoriteta, koska se tulee return-käskyn jälkeen console.log(day) ; ) // yritetään saada tulos funktiosta, joka sisältää return-lauseen ilman arvoa console.log(sayDay("21. helmikuuta 2016")); JavaScript - Hanki arvo funktiosta, joka ei palauta mitään 
Sama tulos saadaan, jos return-lause ei määritä palautusarvoa.
Funktioiden ylikuormitus JavaScriptissäFunktioiden ylikuormitus ohjelmoinnissa on kykyä ilmoittaa useita samoilla nimillä olevia toimintoja samassa laajuudessa. Tällaiset funktiot eroavat toisistaan argumenttien tyypin ja lukumäärän suhteen. Jokaisella funktiolla on oma ohjelmalogiikkansa. Toimintojen ylikuormitusta käytetään, jotta samanlaiset toiminnot voidaan suorittaa yhdellä funktion nimellä.
JavaScript-kieli ei tue toimintojen ylikuormitusta samalla tavalla kuin se on toteutettu esimerkiksi C:ssä vastaavia kieliä. Nuo. JavaScriptissä ei voi luoda useita samoilla nimillä olevia funktioita, jotka ovat samassa laajuudessa.
Samanlaiset toiminnot voidaan toteuttaa JavaScriptissä seuraavien vaiheiden avulla:
- Jos haluat tarkistaa, onko argumentti hyväksytty vai ei, käytä ehtoa, joka tarkistaa sen arvon määrittämättömälle .
- Voit tarkistaa funktiolle välitettyjen argumenttien määrän käyttämällä objektin argumenttien pituus -ominaisuutta.
- Selvittääksesi välitetyn argumentin arvon tyypin, käytä typeof- tai instanceof-operaattoreita.
- Työskennellä jonkun kanssa muuttuva numero argumentit, käytä argumentit-objektia.
- ECMAScript6:sta alkaen voit määrittää argumenteille oletusarvot.
Luodaan esimerkiksi funktio, joka voidaan kutsua yhdellä tai kahdella argumentilla:
//ilmoitus funktiosta, joka muuttaa väriä tausta elementtifunktio setBgColor(bgColor,elements) ( //jos elementtiparametria ei ole määritetty kutsuttaessa if (elements=== undefined) ( //aseta sen arvoksi "div" elements = "div"; ) //hae kaikki elementit elementit = $(elements) // toistaa kaikki elementit ja aseta ne määritettyihin taustaväreihin elements.each(function())( $(this).css("background-color",bgColor); )) / *Kutsu setBgColor-funktiota määrittämällä yksi parametri. Koska 2-parametria ei ole määritetty, tämä toiminto muuttaa kaikkien div-elementtien taustavärin.*/ setBgColor("green"); /*Kutsu setBgColor-funktiota ja määritä 2 parametria. Koska 2 parametri määritetään sitten tämä toiminto muuttaa vain painikeelementtien taustaväriä.*/ setBgColor("#ff0000","button");
Tehdään joitain muutoksia yllä olevaan koodiin. Nimittäin määritämme oletusarvon toiselle parametrille:
//elementtien taustaväriä muuttavan funktion ilmoitus //elementtien parametrin arvo on "div" oletuksena funktio setBgColor(bgColor,elements = "div") ( //get all elements elements = $(elements); //iteroi kaikki elementit ja aseta ne määritettyihin taustaväreihin elements.each(function())( $(this).css("background-color",bgColor); ) ) //kutsu setBgColor-funktiota määrittämällä yksi parametri setBgColor("vihreä" ); //kutsu setBgColor-funktiota määrittäen 2 parametria setBgColor("#ff0000","button");
Esimerkki siitä, kuinka JavaScriptissä voit ottaa käyttöön "ylikuormitetun" toiminnon, joka laskee ihmisen tarvitseman kalorimäärän päivässä:
// funktion funktion kuvaus countCal(sukupuoli, pituus) ( // parametrit: sukupuoli (sukupuoli) ja pituus (korkeus) var tulos; if ((sukupuoli === 0) || (sukupuoli === "mies") ) ( tulos = (pituus - 100) * 20; ) else if ((sukupuoli === 1) || (sukupuoli === "nainen")) (tulos = (pituus - 105) * 19; ) if (tulos ) ( // argumentit - aktiivisuustaso if (argumentit) ( tulos *= argumentit; ) console.log("Kcal:n määrä normaalille elämälle: " + tulos) else ( console.log("Väärät parametrit"); ) ) / * kutsua funktiota ja välittää sille 2 argumenttia (1 - "mies", se voidaan käyttää nimellä sukupuoli ja argumentit; 2 - arvo 185, se voidaan käyttää nimellä sukupuoli ja argumentit) */ countCal(" mies", 185); /* kutsua funktiota ja välittää sille 3 parametria, vaikka funktion kuvauksessa on vain 2 (tässä tapauksessa saat 3. parametrin arvon vain argumentteina) */ countCal(0, 185, 2);
RekursioRekursio on kehossa jonkin toiminnon kutsu itselleen.
Funktiota kutsutaan yleensä sen mukaan, kuinka se on ilmoitettu nimellä tai muuttujalla, joka sisältää viittauksen funktioon.
Funktio fact(n) ( if (n === 1) ( return 1; ) return fact(n-1) * n; ) console.log(fact(5)); // 120
Voit kutsua funktiota sen rungossa paitsi nimellä, myös käyttämällä argumenttiobjektin callee-ominaisuutta. Mutta tämä omaisuus Parempi olla käyttämättä sitä, koska... se on vanhentunut. Lisäksi tiukassa tilassa se ei toimi ollenkaan.
Mitä ovat sisäänrakennetut (vakio) toiminnot?JavaScriptissä on valtava joukko sisäänrakennettuja (vakio) toimintoja. Nämä toiminnot on jo kuvattu itse selainmoottorissa. Lähes kaikki ne ovat yhden tai toisen kohteen menetelmiä.
Esimerkiksi sisäänrakennetun funktion (menetelmän) hälytyksen kutsumiseksi sitä ei tarvitse ilmoittaa ensin. Se on jo kuvattu selaimessa. Puhelu hälytysmenetelmä tehdään määrittämällä nimi, sulkeet ja argumentti niiden sisällä. Tämä menetelmä suunniteltu näyttämään viesti näytöllä valintaikkunan muodossa. Tekstiviesti on otettu tämän funktion parametriarvosta.
// hälytysfunktion kutsuminen alert("Jotkin tekstiä"); JavaScript - Hälytystoiminnon kutsuminen 
