Artikel in ontwikkeling!

Een artikel waarin we zullen bekijken wat een functie is, evenals de traditionele (klassieke) versie van het werken ermee. Daarnaast zullen we analyseren wat de argumenten (parameters) van de functie en de retouroperator zijn.

Wat is een functie?

Een functie is een reeks instructies waaraan een naam kan worden gegeven en die vervolgens vanaf elke plek in het programma met die naam kan worden geopend.

Een klassiek voorbeeld van het gebruik van een functie.

Er staat JavaScript-code op een webpagina, waarvan een fragment meerdere keren wordt herhaald. Om dit te voorkomen, kunt u dit fragment als een functie opmaken en het vervolgens op de benodigde plaatsen in de code aanroepen met de naam van deze functie. Als u deze functie aanroept, betekent dit dat u de instructies erin uitvoert.

• Hoe organiseer ik de uitvoering van een taak in JavaScript met behulp van functies? Om dit te doen, doe je meestal dit:
• verdeel de taak in zijn samenstellende delen (subtaken);
• subtaken worden geformaliseerd via functies;

ontwikkel de hoofdcode met behulp van aanroepen naar de gemaakte functies.

Hierdoor wordt zo’n programma meer gestructureerd. Het is gemakkelijker om verschillende wijzigingen aan te brengen en nieuwe functies toe te voegen.

Een functie declareren en aanroepen

• Bewerkingen met een functie in JavaScript kunnen in 2 stappen worden verdeeld:
• declaratie (creatie) van een functie.

roep (voer uit) deze functie. Functieverklaring. Het maken van een functie in JavaScript begint met schrijven

trefwoord

function , vervolgens wordt de naam van de functie aangegeven, vervolgens worden parameters tussen haakjes x vermeld, indien nodig, worden instructies aangegeven, die tussen accolades staan.

// functiedeclaratie someName function someName() ( alert("Je hebt functie someName aangeroepen!"); ) JavaScript - Syntaxis van functiedeclaratie

Een functie kan zoveel parameters hebben als gewenst, of helemaal geen. Haakjes zijn in ieder geval opgenomen. Als er meerdere parameters zijn, moeten deze worden gescheiden door een komma. Functieparameters zijn toegankelijk via hun naam.

Een reeks instructies tussen accolades is de functiecode die wordt uitgevoerd wanneer deze wordt aangeroepen.

Functie oproep.

De gedeclareerde functie zelf wordt niet uitgevoerd. Om het uit te voeren, moet het worden aangeroepen. Een functie wordt aangeroepen door de naam en twee haakjes op te geven. Argumenten worden indien nodig tussen haakjes vermeld.

// roep de functie uit het vorige voorbeeld someName();

JavaScript - Syntaxis van functieaanroepen Is een functie een object in JavaScript? Functies in JavaScript zijn objecten.

In JavaScript is alles een object behalve zes

primitieve soorten

gegevens. En als de functie een object is, kan een verwijzing ernaar in een variabele worden opgeslagen.

// function declaratie someName function someName() ( alert("Je hebt de someName-functie aangeroepen!"); ) var reference = someName;

Hierna kunt u de functie als volgt aanroepen:

Referentie();

Functieparameters en argumenten

Functieargumenten zijn waarden die aan een functie worden doorgegeven wanneer deze wordt aangeroepen. Argumenten worden van elkaar gescheiden door middel van een komma.

// roep de functie SayWelcome aan en geef er twee argumenten aan SayWelcome("Ivan", "Ivanov"); // nog een aanroep van de functie SayWelcome met twee argumenten SayWelcome("Petr", "Petrov");

Functieparameters zijn een van de manieren in JavaScript om toegang te krijgen tot argumenten binnen een functie. De parameters van de functie in de fase van de declaratie ervan worden tussen haakjes beschreven.

Laten we bijvoorbeeld de functie uit het bovenstaande voorbeeld aanroepen, zonder een of twee parameters op te geven:

// de functie SayWelcome aanroepen en er één argument aan doorgeven SayWelcome("Peter"); // Welkom, ongedefinieerd Peter // roept de functie SayWelcome aan zonder er argumenten aan door te geven SayWelcome(); // Welkom, ongedefinieerd ongedefinieerd

Een voorbeeld van een functie die eenvoudigweg de doorgegeven argumenten naar de browserconsole uitvoert:

// functiedeclaratie function outputParam(param1, param2, param3) ( console.log(param1 + "; " + param2 + "; " + param3); ) // roept de functie outputParam op en geeft deze door verschillende hoeveelheden parameters outputParam("Regen", "Sneeuw", "Mist"); // Regen; Sneeuw; MistuitvoerParam(17); // 17; ongedefinieerd; ongedefinieerde uitvoerParam(24,33); // 24; 33; ongedefinieerde uitvoerParam(); // ongedefinieerd; ongedefinieerd; ongedefinieerd

Een andere manier om toegang te krijgen tot argumenten binnen een functie is door het object speciale argumenten te gebruiken. Toegang krijgen tot argumenten via argumenten is hetzelfde als toegang krijgen tot elementen reguliere reeks, d.w.z. op basis van hun serienummers. Met argument - kunt u dus het eerste argument verkrijgen, argumenten - het tweede argument, enz.

// functiedeclaratie som functie sum(num1, num2) ( /* num1 of argumenten – haal de waarde op van argument 1 num2 of argumenten – krijg de waarde van argument 2 */ var sum1 = num1 + num2, sum2 = argumenten + argumenten; return "Som, verkregen door de 1e methode is gelijk aan " + sum1 + "; de som verkregen door de 2e methode is " + sum2 ) /* voer het resultaat van de somfunctie uit naar de console 7 - het eerste argument (it kan worden benaderd met de naam num1 of met behulp van argumenten) 4 - tweede argument (het kan worden geopend met de naam num2 of met behulp van argumenten) */ console.log(sum(7,4));

Het belangrijkste verschil tussen deze methoden is dat je met de eerste methode alleen toegang hebt tot de argumenten die een naam hebben gekregen tijdens de functiedeclaratiefase. Met de tweede methode kun je de waarde van elk argument achterhalen, zelfs als het geen naam heeft (by serienummer). Dit is een kans JavaScript-taal Hiermee kunt u universele flexibele functies creëren.

Naast het ontvangen van argumenten, kunt u met het object argumenten ook hun aantal kennen. Dit wordt gedaan met behulp van de lengte-eigenschap.

U kunt de argumenten herhalen die aan de functie zijn doorgegeven, bijvoorbeeld met behulp van voor lus of voor...van .

// function declaratie sum function sum() ( var i = 0; console.log("Voer alle argumenten uit met behulp van een for-lus"); 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);

Een functie die alle argumenten en hun nummer aan de console weergeeft:

// function declaratie function myFunction () ( var i; console.log("Aantal doorgegeven parameters = " + argumenten.lengte); // laten we alle parameters doornemen met behulp van een for-lus voor (i = 0; i< arguments.length; i++) { console.log(i + " параметр = " + arguments[i]); } } // вызовы функции myFunction myFunction(3, 7, 27, "JavaScript"); myFunction(); myFunction("Яблоки", "Груши", "Апельсины");

Een functie die de optelling uitvoert van alle argumenten die eraan zijn doorgegeven (hun aantal is vooraf onbekend):

// functiedeclaratie var myCalc = function() ( // laten we alle parameters doornemen met behulp van de for lus var i, sum = 0; for (i = 0; i lt; arguments.length; i++) ( sum += argumenten [i] ) // retourneer de som als resultaat return sum ) // functieaanroep (uitvoer naar de console) console.log(myCalc(4, 20, 17, -6));

Als gevolg hiervan kunt u met behulp van het arguments-object het volgende in de functietekst implementeren:

• het controleren van het aantal doorgegeven argumenten;
• een willekeurig aantal parameters verwerken.

Naast de functie zelf hebben andere functies die zich daarin bevinden ook toegang tot de argumenten die eraan worden doorgegeven in de aanroepfase.

Functie mainF(p1, p2) ( functie childF() ( console.log("p1 = " + p1 + "; p2 = " + p2); ) childF(); ) mainF(3, 5); // p1 = 3; p2 = 5 hoofdF(4, 7); // p1 = 4; p2 = 7

Standaardinstellingen

Vanaf ECMAScript 2015 (6) kan een functieparameter worden ingesteld op de standaardwaarde.

Laten we bijvoorbeeld de parameter 'color' instellen op de standaardwaarde, gelijk aan '#009688':

Functie setBGColor(color = "#009688") ( document.body.style.backgroundColor = kleur; ) setBGColor(); // de achtergrondkleur is #009688 setBGColor("red"); // de achtergrondkleur is rood

Vóór ECMAScript 2015 kon u de parameter bijvoorbeeld als volgt instellen op de standaardwaarde:

Functie setBGColor(color) ( color = kleur !== ongedefinieerd ? color: "#009688"; // stel kleur in op de standaardwaarde van "#009688" document.body.style.backgroundColor = kleur; )

Overige parameters

Als u bij het aanroepen van een functie meer argumenten doorgeeft dan er parameters zijn, kunt u de overige argumenten verkrijgen met behulp van de zogenaamde restpatameters. Deze kans verscheen in de taal die begint met ECMAScript 2015.

// ...nums - de overige parameters, die in dit geval toegankelijk zijn via de naam nums function doMath(mathAction, ...nums) ( var result = 0; nums.forEach(function(value) ( ​​switch ( mathAction) ( case "sum": resultaat += waarde; break; resultaat += waarde**3; break; ) return resultaat ) 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)

verklaring terug

De return-instructie is bedoeld om een ​​waarde of het resultaat van de evaluatie van een expressie te retourneren huidige functie. De waarde of expressie moet door een spatie van de return worden gescheiden. Bovendien stopt de return-instructie de uitvoering van de functie, d.w.z. alle instructies die daarop volgen, worden niet uitgevoerd.

Een functie in JavaScript retourneert altijd een resultaat, ongeacht of er een return-instructie wordt gebruikt of niet.

// functie die de resultaatfunctie retourneert SayWelcome (userFirstName, userLastName) ( if ((!userFirstName) || (!userLastName)) return "Welcome, anonieme gebruiker"; else return "Welcome, " + userLastName + " " + userFirstName; ) // declareer de variabele person var person; // wijs het resultaat van de functie SayWelcome toe aan de variabele person person = SayWelcome("Ivan","Ivanov" ); // print de waarde van de variabele naar de console console.log(person); //Instructie die het resultaat van de functie op de console zal weergeven SayWelcome console.log(sayWelcome("Petr", "Petrov")) ; //Instructie die het resultaat van de functie op de console weergeeft SayWelcome console.log(sayWelcome("Sidorov"));

Een functie in JavaScript retourneert altijd een resultaat als resultaat van de uitvoering ervan, zelfs als dit niet expliciet is gedefinieerd met behulp van de return-instructie. Dit resultaat is niet gedefinieerd.

// 1. functie die geen resultaat retourneert, functie SayWelcome (userFirstName, userLastName) ( console.log("Welcome, " + userLastName + " " + userFirstName); ) // laten we proberen het resultaat te krijgen van een functie die dat wel doet retourneert niets console .log(sayWelcome("Ivan", "Ivanov")); // 2. functie die een return-instructie bevat zonder een waardefunctie SayDay (dag) ( day = "Vandaag," + dag; return; //deze instructie wordt niet uitgevoerd omdat deze na de return-instructie console.log(day) komt ; ) // laten we proberen het resultaat te verkrijgen van een functie die een return-instructie bevat zonder waarde console.log(sayDay("21 februari 2016");

JavaScript - Haal waarde uit een functie die niets retourneert

Hetzelfde resultaat wordt verkregen als de retourinstructie geen retourwaarde specificeert.

Functie-overbelasting in JavaScript

Functie-overbelasting bij het programmeren is de mogelijkheid om meerdere functies met dezelfde naam in hetzelfde bereik te declareren. Dergelijke functies verschillen van elkaar in het type en aantal argumenten. Elke functie heeft zijn eigen programmalogica. Er wordt gebruik gemaakt van functieoverbelasting, zodat soortgelijke acties kunnen worden uitgevoerd met behulp van een enkele functienaam.

De JavaScript-taal ondersteunt functie-overbelasting niet op dezelfde manier als deze bijvoorbeeld in C-achtige talen wordt geïmplementeerd. Die. In JavaScript kunt u niet meerdere functies met dezelfde naam maken die zich binnen hetzelfde bereik bevinden.

• Soortgelijke functionaliteit kan in JavaScript worden geïmplementeerd met behulp van de volgende stappen:
• Om te controleren of een argument wel of niet wordt doorgegeven, gebruikt u een voorwaarde die de waarde ervan controleert op undefined .
• Om het aantal argumenten dat aan een functie wordt doorgegeven te controleren, gebruikt u de eigenschap arguments length van het object.
• Om erachter te komen welk type argumentwaarde is doorgegeven, gebruikt u de operatoren typeof of instanceof. Om mee te werken variabel getal
• argumenten, gebruik dan het object argumenten.

Vanaf ECMAScript6 kunt u standaardwaarden voor argumenten opgeven.

Laten we bijvoorbeeld een functie maken die kan worden aangeroepen met een of twee argumenten: //verklaring van een functie die van kleur verandert elements function setBgColor(bgColor,elements) ( //als de elementparameter niet is opgegeven bij het aanroepen van if (elements=== undefined) ( //stel dan de waarde in op "div" elements = "div"; ) //get all elements elements = $(elements); // doorloop alle elementen en stel ze in op de opgegeven achtergrondkleur elements.each(function())( $(this).css("background-color",bgColor); )) / *Roep de functie setBgColor aan en geef één parameter op. Omdat 2-parameter niet is opgegeven, zal deze functie de achtergrondkleur van alle div-elementen wijzigen.*/ setBgColor("green"); /*Roep de functie setBgColor aan, waarbij u twee parameters opgeeft. Omdat Vervolgens wordt parameter 2 opgegeven

deze functie

zal alleen de achtergrondkleur van de knopelementen veranderen.*/ setBgColor("#ff0000","button");

Laten we enkele wijzigingen aanbrengen in de bovenstaande code. We specificeren namelijk de standaardwaarde voor de tweede parameter:

//declaratie van een functie die de achtergrondkleur van elementen verandert //de parameter elements heeft standaard de waarde "div" functie setBgColor(bgColor,elements = "div") ( //get all elements elements = $(elements); // herhaal alle elementen en stel ze in op de opgegeven achtergrondkleur elements.each(function())( $(this).css("background-color",bgColor); ) ) //roep de setBgColor-functie aan, waarbij u één parameter specificeert setBgColor("groen" ); //roep de functie setBgColor aan, waarbij u 2 parameters specificeert setBgColor("#ff0000","button");

Een voorbeeld van hoe je in JavaScript een ‘overbelaste’ functie kunt implementeren die berekent hoeveel calorieën een mens per dag nodig heeft:

// beschrijving van de functie functie countCal(sex, height) ( // parameters: sex (sex) en height (height) var result; if ((sex === 0) || (sex === "man") ) ( resultaat = (lengte - 100) * 20; ) else if ((geslacht === 1) || (geslacht === "vrouw")) ( resultaat = (lengte - 105) * 19; ) if (resultaat ) ( // argumenten - activiteitsniveau if (argumenten) ( resultaat *= argumenten; ) console.log("Hoeveelheid kcal voor normaal leven: " + resultaat) else ( console.log("Onjuiste parameters"); ) ) / * een functie aanroepen en er 2 argumenten aan doorgeven (1 - "man", deze is toegankelijk met de naam sex en argumenten; 2 - de waarde 185, deze is toegankelijk met de naam sex en argumenten) */ countCal(" mens", 185); /* roept een functie aan en geeft er 3 parameters aan door, hoewel er slechts 2 aanwezig zijn in de functiebeschrijving (in dit geval kunt u de waarde van de derde parameter alleen als argumenten krijgen) */ countCal(0, 185, 2);

Een functie wordt gewoonlijk aangeroepen, afhankelijk van hoe deze wordt gedeclareerd op naam of op basis van een variabele die een verwijzing naar de functie bevat.

Functie feit(n) ( if (n === 1) ( retourneer 1; ) retourneer feit(n-1) * n; ) console.log(fact(5)); // 120

U kunt een functie in de hoofdtekst niet alleen bij naam aanroepen, maar ook door de eigenschap callee van het arguments-object te gebruiken. Maar dit pand Het is beter om het niet te gebruiken, omdat... het is verouderd. Bovendien werkt het in de strikte modus helemaal niet.

Wat zijn ingebouwde (standaard)functies?

JavaScript heeft een enorme set ingebouwde (standaard) functies. Deze functies worden al beschreven in de browserengine zelf. Bijna allemaal zijn het methoden van het ene of het andere object.

Om bijvoorbeeld de ingebouwde functie (methode) alert aan te roepen, hoeft deze niet eerst te worden gedeclareerd. Het wordt al beschreven in de browser. Telefoongesprek waarschuwingsmethode wordt gedaan door een naam, haakjes en een argument daarin op te geven. Deze methode is ontworpen om een ​​bericht op het scherm weer te geven in de vorm van een dialoogvenster. Sms-bericht wordt overgenomen uit de parameterwaarde van deze functie.

// de waarschuwingsfunctie aanroepen alert("Sommige tekst");

JavaScript - De waarschuwingsfunctie oproepen

• 24 mei 2011 om 01:13 Vijf manieren om een ​​functie aan te roepen

• JavaScript

Vertaling Ik kom vaak JavaScript-code tegen waarbij fouten worden veroorzaakt door een misverstand over hoe functies in JavaScript werken (trouwens, een groot deel van deze code is door mij geschreven). JavaScript is een taal met meerdere paradigma's en beschikt over mechanismen functionele programmering

. Het is tijd om deze mogelijkheden te verkennen. In dit artikel vertel ik je vijf manieren om functies in JavaScript aan te roepen. In de eerste fasen JavaScript leren Beginners denken meestal dat de functies ervan op vrijwel dezelfde manier werken als bijvoorbeeld C#. Maar de mechanismen voor het aanroepen van functies in JavaScript hebben een aantal belangrijke verschillen

, en onwetendheid hierover kan resulteren in fouten die niet gemakkelijk te vinden zijn. Laten we schrijven eenvoudige functie
, wat een array van drie elementen retourneert: de huidige waarde en de twee argumenten die aan de functie zijn doorgegeven.

functie makeArray(arg1, arg2)( return [ this, arg1, arg2 ]; )
De meest gebruikelijke manier: globale oproep Beginners declareren vaak functies zoals weergegeven in het bovenstaande voorbeeld. Het aanroepen van deze functie is eenvoudig:
makeArray("één", "twee"); // => [venster, "één", "twee" ]

In JavaScript is het altijd gedefinieerd, ongeacht of het script in de browser of in een andere omgeving wordt uitgevoerd mondiaal voorwerp. Elke code in ons script die nergens aan "gebonden" is (dat wil zeggen, buiten de objectdeclaratie) bevindt zich feitelijk in de context van het globale object. In ons geval is makeArray niet zomaar een functie die op zichzelf ‘loopt’. In feite is makeArray een methode van het globale object (in het geval van code-uitvoering in de browser) window . Het is gemakkelijk te bewijzen:
alert (type venster. methode die niet bestaat); // => ongedefinieerde waarschuwing (type venster.makeArray); // => functie
Dat wil zeggen: makeArray("one", "two"); is gelijk aan het aanroepen van window.makeArray("one", "two"); .

Het spijt me dat dit de meest gebruikelijke manier is om functies aan te roepen, omdat het de aanwezigheid van een globale functie impliceert. En we weten allemaal dat globale functies en variabelen niet de beste vorm zijn bij programmeren. Dit geldt vooral voor JavaScript. Vermijd globale definities, en u zult er geen spijt van krijgen.

Functieaanroepregel #1: Als een functie rechtstreeks wordt aangeroepen, zonder een object op te geven (bijvoorbeeld myFunction()), is de waarde hiervan het globale object (venster als de code in de browser wordt uitgevoerd).

Een methode aanroepen Laten we een eenvoudig object maken en van makeArray de methode ervan maken. We declareren het object met behulp van de letterlijke notatie en roepen vervolgens onze methode aan:
// maak een object var arrayMaker = ( someProperty: "een waarde", make: makeArray ); // roep de make() methode arrayMaker.make("one", "two"); // => [ arrayMaker, "één", "twee" ] // alternatieve syntaxis, gebruik vierkante haakjes arrayMaker["make"]("one", "two"); // => [ arrayMaker, "één", "twee" ]
Zie jij het verschil? De waarde hiervan is in dit geval het object zelf. Waarom niet window , zoals in het vorige geval, aangezien de functiedeclaratie niet is veranderd? Het geheim is hoe functies worden doorgegeven in JavaScript. Functie is standaard JavaScript-type, wat eigenlijk een object is, en net als elk ander object kunnen functies worden doorgegeven en gekopieerd. In dit geval hebben we feitelijk de gehele functie gekopieerd, inclusief de argumentenlijst en de hoofdtekst, en het resulterende object toegewezen aan de make-eigenschap van het arrayMaker-object. Dit komt overeen met deze verklaring:
var arrayMaker = ( someProperty: "Een waarde"; make: function (arg1, arg2) ( return [ this, arg1, arg2]; ) );
Regel #2 voor het aanroepen van functies: in een functie die wordt aangeroepen met behulp van de syntaxis van de methodeaanroep, zoals obj.myFunction() of obj["myFunction"]() , heeft deze de waarde obj .

Een verkeerd begrip van dit doorgaans eenvoudige principe leidt vaak tot fouten bij het verwerken van gebeurtenissen:
function buttonClicked())( var text = (dit === venster) ? "window": this.id; alert(text); ) var button1 = document.getElementById("btn1"); var button2 = document.getElementById("btn2"); button1.onclick = knopgeklikt; button2.onclick = functie())( buttonClicked(); );
Als u op de eerste knop klikt, wordt een bericht weergegeven "btn1" omdat we in dit geval een functie als een methode aanroepen, en deze binnen de functie krijgt de waarde van het object waartoe deze methode behoort. Als u op de tweede knop klikt, wordt dit weergegeven "raam" omdat we in dit geval buttonClicked rechtstreeks aanroepen (dus niet zoals obj.buttonClicked()). Hetzelfde gebeurt wanneer we een gebeurtenishandler aan de elementtag toewijzen, zoals in het geval van de derde knop. Als u op de derde knop klikt, wordt hetzelfde bericht weergegeven als de tweede.

Als u bibliotheken zoals jQuery gebruikt, hoeft u hier niet over na te denken. jQuery zorgt ervoor dat de this-waarde in de gebeurtenishandler wordt herschreven, zodat de this-waarde het element is dat de gebeurtenis heeft gegenereerd:
// gebruik jQuery $("#btn1").click(function() (alert(this.id); // jQuery zorgt ervoor dat "dit" een knop is));
Hoe slaagt jQuery erin de waarde hiervan te veranderen? Lees hieronder.

Nog twee manieren: apply() en call() Het is logisch dat hoe vaker u functies gebruikt, hoe vaker u ze moet doorgeven en in verschillende contexten moet aanroepen. Vaak is het nodig om de waarde hiervan te overschrijven. Weet je nog, functies in JavaScript zijn objecten. In de praktijk betekent dit dat functies vooraf gedefinieerde methoden hebben. apply() en call() zijn er twee van. Hiermee kunt u deze waarde overschrijven:
var auto = ( jaar: 2008, model: "Dodge Bailout"); makeArray.apply(auto, ["één", "twee"]); // => [ auto, "één", "twee" ] makeArray.call(auto, "één", "twee"); // => [ auto, "één", "twee" ]
Deze twee methoden lijken erg op elkaar. De eerste parameter overschrijft dit. De verschillen daartussen zitten in de volgende argumenten: Function.apply() accepteert een array van waarden die aan de functie worden doorgegeven, terwijl Function.call() de argumenten afzonderlijk accepteert. In de praktijk is het naar mijn mening handiger om apply() te gebruiken.

Functieaanroepregel #3: Als u de waarde hiervan wilt overschrijven zonder de functie naar een ander object te kopiëren, kunt u myFunction.apply(obj) of myFunction.call(obj) gebruiken.

Constructors Ik zal niet in detail treden over het declareren van aangepaste typen in JavaScript, maar ik denk dat het belangrijk is om u eraan te herinneren dat er geen klassen zijn in JavaScript, en dat elk aangepast type een constructor nodig heeft. Daarnaast methoden aangepast type Het is beter om het te declareren met prototype , wat een eigenschap is van de constructorfunctie. Laten we ons eigen type maken:
// declareer de constructorfunctie ArrayMaker(arg1, arg2) ( this.someProperty = "maakt niet uit"; this.theArray = [ this, arg1, arg2 ]; ) // declareer methoden ArrayMaker.prototype = ( someMethod: function () ( alert( "Aangeroepen door een methode"); getArray: function () ( retourneer this.theArray; ) ); var am = new ArrayMaker("één", "twee"); var other = new ArrayMaker("eerste", "tweede"); am.getArray(); // => [ ben, "één", "twee" ]
Het belangrijkste in dit voorbeeld is de aanwezigheid van de nieuwe operator vóór de functieaanroep. Als dit niet het geval was, zou het een globale oproep zijn en zouden de eigenschappen die in de constructor zijn gemaakt tot het globale object behoren. Dat hebben wij niet nodig. Bovendien retourneren constructors waarden meestal niet expliciet. Zonder de new operator zou de constructor undefined teruggeven, en daarmee dit. Goede stijl er wordt rekening gehouden met de namen van de constructeurs hoofdletter; Dit zal u herinneren aan de noodzaak van de nieuwe operator.

Anders zal de code in de constructor waarschijnlijk vergelijkbaar zijn met code die u in een andere taal zou schrijven. De waarde hiervan is in dit geval het nieuwe object dat u maakt.

Functieaanroepregel nr. 4: Bij het aanroepen van een functie met exploitant nieuw, zal de waarde hiervan een nieuw object zijn dat door de JavaScript-runtime is gemaakt. Als deze functie geen enkel object expliciet retourneert, wordt dit impliciet geretourneerd.

Conclusie Hopelijk begrijp ik het verschil tussen op verschillende manieren Met functieaanroepen kunt u uw JavaScript-code verbeteren. Soms zijn fouten met betrekking tot deze waarde moeilijk te onderkennen, dus het is verstandig om ze van tevoren te voorkomen.

Met JavaScript-functies kunt u scripts organiseren en vereenvoudigen hergebruiken code. In plaats van lange stukken code te creëren die over een HTML-pagina verspreid zijn, worden scripts in logische groepen georganiseerd.

Een JavaScript-functie declareren en aanroepen

De syntaxis van de JavaScript-functie is als volgt:

functie ""naam"" (""argument1"", ""argument2"", ""argument3"" ...) ( ""operatoren"" retourneren ""waarde"" )

De naam bepaalt hoe we de functie zullen noemen wanneer we deze aanroepen. De argumenten specificeren de waarden die ter verwerking aan de functie worden doorgegeven. De sectie met instructies vertegenwoordigt de hoofdtekst van de functie die de verwerking uitvoert. Met de optionele return-instructie kunt u een waarde retourneren.

Het volgende voorbeeld toont een functie die in de sectie van een HTML-pagina is gedefinieerd en in de sectie wordt aangeroepen:

functie zegHallo() ( alert("Hallo!"); ) zegHallo();

Argumenten doorgeven aan een functie

In het bovenstaande voorbeeld (scripttype tekst JavaScript-functie) worden er geen argumenten doorgegeven aan de functie. Normaal gesproken is een functie ontworpen om een ​​actie uit te voeren met verschillende argumenten:

Een eenvoudig voorbeeld van een JavaScript-functiefunctie SayHello(dag, maand) ( alert("Hallo! Vandaag is het " + dag + " " + maand); ) SayHello("24", "Juli"); zeg Hallo("1", "Augustus"); zeg Hallo("24", "Mei");

In dit voorbeeld wordt de JavaScript-callback-functie meerdere keren aangeroepen, waarbij argumenten worden gebruikt die vervolgens worden gebruikt om een ​​tekenreeks te maken die in het dialoogvenster wordt weergegeven. Om dit zonder de functie te doen, zou u het script in de sectie drie keer moeten herhalen. Het is duidelijk dat het gebruik van een functie een efficiëntere aanpak is.

Een waarde retourneren uit een functie

De return-instructie wordt gebruikt om een ​​waarde uit een functie terug te geven en deze te gebruiken op de plaats waar de functie wordt aangeroepen. Als voorbeeld declareren we een functie die twee argumenten optelt en het resultaat retourneert:

Een eenvoudig voorbeeld van een JavaScript-functie var result = addValues(10, 20) document.write("Result = " + result);

In het bovenstaande voorbeeld geven we de waarden 10 en 20 door aan de functie addValues. De functie addValues ​​telt deze twee waarden op en retourneert het resultaat. De return-instructie wijst het resultaat toe aan de resultaatvariabele, die vervolgens wordt gebruikt om een ​​tekenreeks te maken die op de HTML-pagina wordt afgedrukt.

De JavaScript-functieaanroep kan worden gedaan in verschillende plaatsen. Het is bijvoorbeeld niet nodig om het resultaat toe te wijzen als de waarde van een variabele. U kunt het direct als argument gebruiken bij het aanroepen van document.write .

Het is belangrijk op te merken dat een functie slechts één waarde kan retourneren:

Een eenvoudig voorbeeld van een JavaScript-functiefunctie addValues(value1, value2) ( return value1 + value2; ) document.write("Result = " + addValues(10, 20));< 20"); }

JavaScript-onclick-functies kunnen ook worden gebruikt in voorwaardelijke instructies. Bijvoorbeeld: Een eenvoudig voorbeeld van een JavaScript-functiefunctie addValues(value1, value2) ( return value1 + value2; ) if (addValues(10, 20) > 20) ( document.write("Resultaat > 20"); ) else ( document.write( "Resultaat

Waar functiedeclaraties moeten worden geplaatst Er zijn twee plaatsen waar het wordt aanbevolen om te plaatsen JavaScript-declaraties functie return: binnen een sectie van een HTML-document of binnen extern bestand

.js. De tweede optie wordt beschouwd als de locatie met de meeste voorkeur, omdat deze de grootste flexibiliteit biedt.

Het doel van het creëren van functies is om ze zo algemeen mogelijk te maken om de herbruikbaarheid te maximaliseren.

De vertaling van het artikel “Understanding JavaScript Functions” werd voorbereid door het vriendelijke projectteam.

Goed slecht De ideeën van het dynamisch genereren van inhoud op een webbron zijn de norm geworden. Statische pagina's

en het bouwen van sjablonen voor websites hebben eindelijk hun missie voltooid.

Een moderne webbron hoeft echter niet noodzakelijkerwijs te worden vertegenwoordigd door een reeks pagina's die door de server zijn gegenereerd en door de browser (JS+AJAX) zijn bijgewerkt. Wanneer een bezoeker arriveert, kan een webbron bestaan ​​uit een paar headers voor het protocol, wat tekst in de ‘head’, een paar regels code in de ‘body’ en dat is alles. De rest" zal met een idee komen

” tijdens de ervaring van de bezoeker - dit is een ideale site of streeft ernaar dat te zijn.

Plaats van beschrijving en essentie van functies JavaScript is een ervaring die gedurende vele decennia is opgedaan. Hij heeft belangrijke geschiedenis

ontwikkeling, een modern gekwalificeerd team van makers en ontwikkelaars. De taal is goed doordacht, betrouwbaar, mooi en geeft ontwikkelaars een echte kans om fatsoenlijke code te schrijven en zichzelf te verbeteren.

Een script is een plek waar de noodzakelijke variabelen en functies worden beschreven, en niet zozeer een goed stuk code dat voor zichzelf is geschreven. Het zijn de functies die essentieel en betekenisvol zijn, misschien hun onderlinge directe verbinding, maar vaker is alles anders. De plaats waar een functie wordt beschreven en de plaats waar deze wordt toegepast, zijn helemaal niet hetzelfde.

Het is helemaal niet nodig dat een functie een andere functie rechtstreeks aanroept; dit kan indirect gebeuren door middel van het genereren van dynamische code. Binnen deze code neemt de bezoeker een beslissing en wordt een heel ander systeem van functies geactiveerd.

Functionele dynamiek

Functionele dynamiek betreft niet alleen en niet zozeer de handlers die aan pagina-elementen zijn toegewezen, het zijn de functies die de pagina-elementen vormen, en ook de directe handlers kunnen veranderen.

De actie op de pagina ontvouwt zich afhankelijk van de elementen en het gedrag van de bezoeker erop. Muisbewegingen, toetsenbordknoppen, klikken, elementgebeurtenissen en andere omstandigheden leiden tot de lancering van de noodzakelijke functies.

Aanvankelijk is er geen opeenvolging en is er geen parallellisme. Er is een adequate reactie van de webbron op gebeurtenissen. Hoe snel JavaScript een bepaalde functie zal uitvoeren, hangt af van veel technische (computer, communicatielijnen) en semantische (algoritmelogica, vakgebied, betekenis van de taak) factoren.

In feite kan worden betoogd dat iets parallel werkte, en dat iets na iets anders zal worden vervuld, maar daar zit geen bijzondere betekenis in. Het is belangrijk dat JavaScript-functies de mogelijkheid bieden om adequaat te reageren op bezoekersacties.

Dit is een nieuw denken in ontwikkeling: gedistribueerde informatieverwerking in de ingewanden van één enkele browser!

Syntaxis van variabelen en functies

JavaScript-variabelen worden zowel in de “script”-tag als in de hoofdtekst van de functie geplaatst. Functies worden op dezelfde manier gedefinieerd. Het heeft geen enkel nut om binnen een functie nog een functie te schrijven, maar dit kan om verschillende en goed onderbouwde redenen nodig zijn.

De beschrijving van een functie begint doorgaans met het sleutelwoord ‘functie’, gevolgd door de naam ervan, een lijst met argumenten tussen haakjes gescheiden door komma’s, en de functietekst in krullende beugels.

IN in dit voorbeeld Er worden twee functies beschreven die AJAX-uitwisseling tussen de pagina en de server mogelijk maken. De scXHR-variabele is hierboven beschreven en is daarom zowel in InitXML als in WaitReplySC beschikbaar.

Functienaam en parameter "functie".

Hier is een asynchrone optie geïntroduceerd, waarbij de JavaScript-functie in de functie wordt aangeroepen nadat de server reageert. Tegelijkertijd heeft WaitReplySC, nadat het een antwoord van de server heeft ontvangen, toegang tot de paginatags, vult deze met de ontvangen informatie en roept andere functies op die mogelijk het volgende verzoek aan de server kunnen initiëren.

Het is ook belangrijk om op te merken dat WaitReplySC een functie is. Maar in de rij scXHR.onreadystatechange = WaitReplySC het wordt doorgegeven als een parameter. Dit algemene regel het doorgeven van functies aan andere functies als parameters. Specificeer haakjes en geef de parameter(s) daarin door - de functie wordt onmiddellijk uitgevoerd. Hij gaf me alleen zijn naam, maar wat dan nog. De functieaanroep wordt gedaan door degene die de naam heeft ontvangen.

Dankzij de functionaliteit die via AJAX is geïmplementeerd, kunt u een JavaScript-functie aanroepen via gegevens die van de server zijn ontvangen. Bij het verzenden van een verzoek naar de server kan het zijn dat een bepaalde functie helemaal niet ‘weet’ tot welke functie hij toegang heeft en met welke informatie.

Functie-exit en het resultaat ervan

In de hoofdtekst van de functie kunt u alle operatoren van de taal schrijven, die in feite voor dit doel bedoeld zijn. Variabelen die binnen en buiten een functie zijn gedefinieerd, zijn beschikbaar binnen een functie, maar niet die welke in andere functies zijn gedefinieerd.

Als u wilt dat een functie een resultaat retourneert, kunt u de JavaScript-retouropdracht gebruiken: return. Er kan een voldoende aantal return-instructies in de functietekst voorkomen. Het is helemaal niet nodig dat ze allemaal hetzelfde type resultaat opleveren.

Meestal respecteren ontwikkelaars deze functie zeer en besluiten ze, afhankelijk van de situatie, de functie zo snel mogelijk te verlaten.

Het is helemaal niet nodig om het hele functie-algoritme te doorlopen als je eerder kunt afsluiten.

Functieargumenten

Argumenten voor een functie worden doorgegeven als een door komma's gescheiden lijst, tussen haakjes en direct achter de naam ervan geplaatst. Variabelenamen worden gebruikt als argumenten, maar waarden kunnen ook rechtstreeks worden doorgegeven. Om een ​​functie door te geven aan een functie in JavaScript, hoeft u alleen maar de naam ervan zonder haakjes op te geven.

Binnen de functie is de variabele argumenten beschikbaar, die de eigenschap lengte heeft. Je hebt toegang tot elk functieargument via argumenten, argumenten, ... tot aan de laatste argumenten.

Het wijzigen van een functieargument is geldig binnen de functie, maar niet daarbuiten. Om iets buiten de functie te veranderen, moet je gebruiken JavaScript-operator retour, waardoor de vereiste waarde naar buiten wordt doorgegeven.

Nadat de functie is voltooid, wordt alles wat verband houdt met de uitvoering ervan vernietigd. Tijdens de uitvoering kan een functie externe variabelen wijzigen, behalve die beschreven in andere functies, inclusief interne.

argumenten heeft een eigenschap callee, die wordt gebruikt om een ​​functie aan te roepen, wat wordt gedaan in op dit moment tijd. Als je jezelf belt, dan JavaScript-optie Met een functie binnen een functie kunt u recursie implementeren.

Functies gebruiken

De belangrijkste zorg van functies is het bedienen van browsergebeurtenissen. Om dit te doen, is het in bijna elke tag mogelijk om de naam van de gebeurtenis en de functie die deze verwerkt, op te geven. Er kunnen meerdere gebeurtenissen worden opgegeven, maar er wordt slechts één functie per gebeurtenis opgegeven.

Eén functie kan meerdere pagina-elementen en meerdere evenementen bedienen. Met behulp van de parameter “this” kunt u informatie doorgeven aan de functie van waaruit deze is aangeroepen.

Een klassiek gebruik van JS-functies zijn gebeurtenishandlers op elementen. In dit voorbeeld wordt de functie scfWecomeGo() of scfWelcomeCancel() aangeroepen in het aanmeldings-/afmeldingsformulier van de bezoeker, en scfMenuItemClick(this) bij het selecteren van de bedieningsmodus.

In het laatste geval wordt de parameter “this” doorgegeven, waardoor je op wonderbaarlijke wijze kunt achterhalen van welke div de oproep afkomstig is. Over het algemeen is JavaScript zo goed in de DOM geïmplanteerd en kunt u zo gemakkelijk door de elementen navigeren en verzamelen noodzakelijke informatie die paginadynamiek kan eenvoudigweg onvoorspelbaar zijn.

Een functie hoeft geen reeks tekens, een getal of een andere functie terug te geven. Het kan een volwaardig HTML-element retourneren, dat het vereiste aantal elementen bevat, met zijn eigen gebeurtenishandlers.

Door een dergelijk element op de pagina te plaatsen, creëert de ontwikkelaar nieuwe functionaliteit, wat goed is in termen van het oplossen van het probleem en het bevredigen van de belangen van bezoekers, maar behoorlijk moeilijk in termen van implementatie.

Wanneer je met een volledige ontwikkeling als deze begint, kun je gemakkelijk in de war raken. eigen code, in functieaanroepen, op momenten waarop deze of gene inhoud van dit of dat deel van de pagina wordt gevormd. Voordat u deze ontwikkelingsrichting inslaat, kan het geen kwaad om alles zorgvuldig af te wegen.

Over gedistribueerd denken

De ontwikkelaar moet denken op het niveau van alle pagina-elementen, op het niveau van alle evenementen, en een duidelijk beeld hebben van hoe alles eigenlijk gebeurt. Het is moeilijk, maar het werk is het waard.

IN JavaScript-uitvoering functies kunnen worden uitgesteld tot een bepaalde gebeurtenis, en er kunnen veel van dergelijke functies zijn, en gebeurtenissen hebben de neiging zich te verspreiden en binnen de ‘zichtbaarheidsscope’ van verschillende handlers te vallen.

In dit voorbeeld werd ergens eerder een functie aangeroepen die de creatie van een menu-item voor bestandsnavigatie initieerde. Verondersteld pagina organisatie, dat wil zeggen dat er slechts zeven bestanden in het venster zijn die kunnen worden verwijderd en verwerkt. U kunt navigeren door op een regel van het bestand te klikken, met behulp van de pijlen op het toetsenbord, of in blokken van zeven regels.

Elke zaak heeft zijn eigen functies. Met andere woorden, in zulke eenvoudig voorbeeld je moet een paar dozijn functies schrijven die op verschillende gebeurtenissen zullen reageren, en sommige van deze functies zullen worden verwerkt verschillende opties en situaties die helemaal geen gebeurtenissen zijn.

Wanneer u bijvoorbeeld een rij verwijdert, moeten de lagere rijen omhoog bewegen. Om dit te doen, moet u ofwel een nieuwe selectie maken, die triviaal en arbeidsintensief is, ofwel de lijnen opnieuw berekenen, array-functies in JavaScript gebruiken en op elegante wijze het doel bereiken.

Functieargumenten en resultaten

Met JavaScript kunt u uw code in een "volledig functionele" staat brengen. Het is normaal dat het argument van een functie een functie is. Een optie is toegestaan ​​als de functie een functie retourneert. JavaScript is hier volkomen ontspannen over.

Dit is een goed mechanisme, maar behoorlijk complex qua implementatie. Technisch gezien is alles toegestaan; alleen een gekwalificeerde ontwikkelaar kan semantisch de logica leveren voor het overbrengen van de “functionaliteit”.

Wanneer binnen JavaScript-functie in een functie - wat er ook gebeurt, maar wanneer een functie een functie genereert, en die ene een andere genereert, dan is het behoorlijk moeilijk om de logica te volgen. In wezen gaat het niet om het toepassen van de kwalificatie, maar om het verkrijgen van een veilig en correct resultaat.

De zorg van de ontwikkelaar is duidelijk en eenvoudig. Er is een probleem, u heeft een oplossing nodig, geen fout zoals “JavaScript-fout, de bewerking is onveilig”, leeg scherm of het stoppen van de hele browserengine.

Als het argument een functie is, geeft de ontwikkelaar een variabele door met speciale eigenschappen, dat wil zeggen: het is geen getal, geen string, geen object. Maar het gebruik van een dergelijk argument kan ertoe leiden dat externe variabelen veranderen en dat het resultaat van de uitvoering van de functie verandert. Afhankelijk van wat er wordt verzonden, zullen er adequate wijzigingen worden aangebracht.

Uitvoering van gegenereerde code

U kunt de uitvoering van code implementeren die is gegenereerd tijdens de werking van andere code met behulp van "eval". Dit wordt niet als een uitstekende oplossing beschouwd, maar vaak kun je de code niet ingewikkelder maken met onnodige functies, maar je beperken tot de banale formatie JavaScript-tekenreeksen code en voer deze eenvoudig uit.

In dit voorbeeld wordt een regel gegenereerd om wat informatie in de huidige div in te voegen. Het div-nummer en de informatie-inhoud zijn verschillend voor verschillende posities, dus een dergelijke oplossing in deze situatie zal niet gegarandeerd de situatie “javascript-fout, de bewerking is onveilig” opleveren, maar zal wel op betrouwbare wijze het gewenste effect opleveren.

Een nuance van het JavaScript-paradigma ‘functie binnen een functie’

Als er een mogelijkheid is om het zonder franjes te doen, is het beter om daarvan te profiteren. Alle genoemde opties zijn goed. Uiteraard is dit in veel gevallen de enige oplossing.

Een klassiek voorbeeld van recursie: faculteit berekenen. Het is vrij moeilijk om een ​​algoritme te schrijven dat in een lus terechtkomt, maar het is heel gemakkelijk om de grenzen van de waarde te overschrijden. De faculteit groeit te snel.

Zowel recursie als een functie die een andere functie aanroept en die een geldige callback kan uitvoeren, zijn echter normaal.

Bijvoorbeeld een gewone tafel. Er kunnen nog andere tabellen in de tabel staan. Nesten kan niet worden beperkt. Het schrijven van een eigen set functies voor elke tabel is een te grote luxe.

Er zijn veel van dergelijke voorbeelden te geven, en dit zullen allemaal echte en dringende taken zijn, die helemaal niet op het gebied van programmeren vallen. Dat is de reden waarom het probleem juist ligt in het feit dat het gecreëerde systeem van functies, of beter gezegd het debuggen en daaropvolgende betrouwbare werking wordt niet een zorg voor JavaScript, maar voor de ontwikkelaar.

Laatste update: 04/09/2018

Functies zijn een reeks instructies die een specifieke actie uitvoeren of een specifieke waarde berekenen.

Syntaxis van functiedefinitie:

Functie functienaam([parameter [, ...]])( // Instructies )

Een functiedefinitie begint met het trefwoord functie gevolgd door de naam van de functie. Een functienaam volgt dezelfde regels als een variabelenaam: deze mag alleen cijfers, letters, onderstrepingstekens en dollartekens ($) bevatten, en moet beginnen met een letter, onderstrepingsteken of dollar.

Na de functienaam worden de parameters tussen haakjes vermeld. Zelfs als een functie geen parameters heeft, bevat deze eenvoudigweg lege haakjes. Vervolgens komt tussen accolades de hoofdtekst van de functie, die een reeks instructies bevat.

Laten we de eenvoudigste functie definiëren:

Functieweergave())( document.write("functie in JavaScript"); )

Deze functie heet display(). Het accepteert geen parameters en het enige wat het doet is een string naar de webpagina schrijven.

Echter eenvoudige definitie De functie is nog niet voldoende om te kunnen werken. Je moet haar nog steeds bellen:

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

Het is niet nodig om functies een specifieke naam te geven. U kunt anonieme functies gebruiken:

Var display = function())( // functiedefinitie document.write("functie in JavaScript"); ) display();

Wat we doen is feitelijk een weergavevariabele definiëren en daaraan een functiereferentie toewijzen. En dan op naam variabele functie genaamd.

We kunnen ook dynamisch functies aan een variabele toewijzen:

Functie goedeMorning())( document.write("Goedemorgen"); ) function goodEvening())( document.write("Goedeavond"); ) var message = goedeMorning; bericht(); // Goedemorgenbericht = goede avond; bericht(); // Goedeavond

Functieparameters

Laten we eens kijken naar het doorgeven van parameters:

Functie display(x)( // functiedefinitie var z = x * x; document.write(x + " kwadraat is gelijk aan " + z); ) display(5); // functieaanroep

De weergavefunctie heeft één parameter nodig: x. Daarom kunnen we bij het aanroepen van een functie er een waarde voor doorgeven, bijvoorbeeld het getal 5, zoals in dit geval.

Als een functie meerdere parameters nodig heeft, kunnen we met behulp van de spread-operator... een reeks waarden voor deze parameters doorgeven uit een array:

Functie som(a, b, c)( laat d = a + b + c; console.log(d); ) som(1, 2, 3); laat getallen = ; som(...nums);

In het tweede geval worden getallen uit de nums-array doorgegeven aan de functie. Maar om niet alleen een array als één waarde te verzenden, maar ook getallen uit deze array, wordt de spread-operator (ellips...) gebruikt.

Optionele parameters

Een functie kan veel parameters bevatten, maar sommige of alle parameters kunnen optioneel zijn. Als er geen waarde wordt doorgegeven voor parameters, worden deze standaard ingesteld op 'ongedefinieerd'.

Functie display(x, y)( if(y === ongedefinieerd) y = 5; if(x === ongedefinieerd) x = 8; let z = x * y; console.log(z); ) display() ; // 40 weergave(6); // 30 weergave(6, 4) // 24

Hier heeft de weergavefunctie twee parameters. Wanneer we een functie aanroepen, kunnen we hun waarden controleren. Bij het aanroepen van een functie is het echter niet nodig om waarden voor deze parameters door te geven. Om te controleren op de aanwezigheid van parameterwaarden wordt een vergelijking met de ongedefinieerde waarde gebruikt.

Er is een andere manier om standaardwaarden voor parameters te definiëren:

Functie display(x = 5, y = 10)( laat z = x * y; console.log(z); ) display(); // 50 weergave(6); // 60 weergave(6, 4) // 24

Als er geen waarden worden doorgegeven aan de parameters x en y, worden deze verkregen als de waarden van respectievelijk de getallen 5 en 10. Deze methode is beknopter en intuïtiever dan vergelijken met ongedefinieerd.

In dit geval kan de standaardwaarde van de parameter worden afgeleid, die de uitdrukking vertegenwoordigt:

Functie display(x = 5, y = 10 + x)( let z = x * y; console.log(z); ) display(); // 75 weergave(6); // 96 weergave(6, 4) // 24

In dit geval hangt de waarde van de parameter y af van de waarde van x.

Indien nodig kunnen wij alle doorgegeven parameters via globaal ontvangen beschikbare array argumenten:

Functieweergave())( var z = 1; for(var i=0; i