Share
Stel dat je een bestand hebt dat 82 regels lang is en alleen uit een reeks uitspraken bestaat. (Ik hoop dat dit klopt, maar alles is mogelijk.) Hoe zou u begrijpen wat het programma doet? Hoe zou je het aanpassen of gebruiken? Het zou moeilijk zijn om iets met deze code te doen, omdat er geen structuur is.
Om dit probleem op te lossen, zou u functies kunnen gebruiken. Een functie is een groep instructies die een specifieke taak uitvoeren. Met functies kunnen we een programma opdelen in kleinere programma's, waardoor onze code leesbaarder, herbruikbaarder en toetsbaarder wordt.
Dit soort functies vermeldt de stappen die het programma moet uitvoeren. Overweeg dat we een programma schrijven om een gebruiker in een website te loggen. Het programma kan uit de volgende taken bestaan:
Elk van deze stappen kan onderdeel zijn van een aanmeldingsfunctie. Dit is een voorbeeldfunctie:
Accentsconagua
function greet () console.log ("Hallo, Wereld"); Dit is de algemene vorm van een functie:
function functionName () statement; uitspraak; enz.
Om de functie uit te voeren (ook bekend als het aanroepen van de functie of het aanroepen van de functie), schrijft u een instructie die deze oproept.
begroeten();
De () is waar we input doorgeven aan de functie. Wanneer we de functie definiëren, wordt de invoer een parameter genoemd. Wanneer we de functie aanroepen, is de invoer de werkelijke waarde en wordt deze het argument genoemd. Voorbeeld:
function greet (naam) console.log ("Hallo," + naam); greet ("Alberta"); // Hallo Alberta Met JavaScript ES6 kunt u functies definiëren met behulp van de pijlsyntaxis. Hier is onze begroetingsfunctie gedefinieerd met behulp van de pijlsyntaxis:
let greet = () => console.log ("Hallo, Wereld");Een functie met één parameter:
let greet = name => console.log ("Hallo," + naam);Een functie met meer dan één parameter:
let greet = (fname, lname) => console.log ("Hello," + fname + "" + name); Een functie met meerdere verklaringen:
let greet = (fname, lname) => let name = fname + "" + name; console.log ("Hallo," + naam); Omdat een pijlfunctie een anonieme functie is, geven we onze functie een naam door deze aan een variabele toe te wijzen. Pijlfuncties kunnen handig zijn als uw functielichaam maar één statement heeft.
Dit soort functie retourneert een waarde. De functie moet eindigen met een return-statement. In dit voorbeeld wordt de som van twee getallen geretourneerd.
functie toevoegen (x, y) return x + y;
Dit is de algemene vorm die een functie voor het retourneren van waarden definieert:
function functionName () statement; uitspraak; etc. terugkeer expressie;
De waarde van uitdrukking is wat wordt uitgevoerd door de functie. Dit soort functie is handig als het in een variabele is opgeslagen.
laat variableName = functionName ();
De scope van een variabele is het gedeelte van het programma waar een variabele toegankelijk is. Een variabele kan lokaal of globaal zijn. Het bereik van een lokale variabele bevindt zich binnen de functie waarin het is gemaakt. Geen enkele code buiten de functie heeft toegang tot de lokale variabelen.
Ook als je gebruikt laat of const om een variabele te declareren, hebben ze een block scope. Een blok is een verzameling instructies die bij elkaar horen als een groep. Een blok kan zo simpel zijn als het omwikkelen van onze code in accolades:
let a = 2;
De variabele een is lokaal voor het blok waarin het zich bevindt. Een blok kan ook een lus of een if-statement zijn. Voorbeeld:
laat a = 1; if (5> 4) let a = 2; console.log (a); // 1
Omdat onze console-instructie in dezelfde reikwijdte ligt als onze eerste variabele een, het toont die waarde, die 1 is. Het heeft geen toegang tot de variabelen binnen het if-blok. Overweeg nu dit voorbeeld:
laat a = 1; if (5> 4) let a = 2; console.log (a); // 2
Nu wordt er 2 weergegeven omdat het bereik van de variabelen waarover onze console-instructie toegang heeft zich binnen het if-blok bevindt. De parameters van een functie zijn ook lokale variabelen en zijn alleen toegankelijk via code binnen de functie. Globale variabelen zijn daarentegen toegankelijk voor alle instructies in het programmabestand. Voorbeeld:
laat a = 1; functie foo () a = 2; console.log (a); // 1 foo (); console.log (a); // 2
In dit voorbeeld, een is een globale variabele, en we hebben er toegang toe binnen de foo-functie. De eerste consoleafspraak toont 1. Na het bellen foo, de waarde van een is ingesteld op 2, waardoor de weergave van de tweede console-instructie 2 wordt weergegeven.
Globale variabelen moeten heel weinig worden gebruikt, idealiter helemaal niet. Omdat algemene variabelen toegankelijk zijn voor elk onderdeel van een programma, lopen ze het risico dat ze op onvoorspelbare manieren worden gewijzigd. In een groot programma met duizenden coderegels wordt het programma moeilijker te begrijpen omdat je niet gemakkelijk kunt zien hoe de variabele wordt gebruikt. Het is beter om lokale variabelen te maken en te gebruiken.
Als u echter een variabele op meerdere plaatsen in uw programma moet gebruiken, is het OK om een globale constante te gebruiken. Een variabele declareren met de const sleutelwoord voorkomt dat het wordt gewijzigd, waardoor het veiliger te gebruiken is. U hoeft zich alleen zorgen te maken over het bijwerken van de waarde van de constante op de plaats waar deze is gedeclareerd.
Bedenk dat een parameter een variabele is die een functie gebruikt om gegevens te accepteren. Aan de parameter wordt de waarde van de argumenten van een functie toegewezen wanneer de functie wordt aangeroepen. Vanaf ES6 kunnen parameters ook standaardwaarden krijgen met het formaat parameterName = value. In dit geval kunt u een functie zonder argumenten aanroepen en standaardwaarden gebruiken. Voorbeeld:
function greet (name = "world") console.log ("Hallo," + naam); begroeten(); //Hallo WereldDe spreid / rust-operator is nieuw voor ES6 en kan worden gebruikt om een array of object uit te breiden tot afzonderlijke waarden of om de parameters van een functie in een array te verzamelen. Dit is een voorbeeld van het gebruik van een rustparameter:
function foo (... args) console.log (args); foo (1, 2, 3, 4, 5); // [1, 2, 3, 4, 5]
Stel nu dat je een bestand hebt met 1.082 regels. (Ik heb dit gezien en je zou moeten rennen als je zoiets tegenkomt.) Het bestand is georganiseerd in functies, maar het is moeilijk om te zien hoe ze zich tot elkaar verhouden.
Om gerelateerd gedrag te groeperen, moeten we onze code in modules plaatsen. Een module in ES6 is een bestand dat gerelateerde functies en variabelen bevat. Met modules kunnen we privé-eigenschappen verbergen en openbare eigenschappen openbaar maken die we in andere bestanden willen gebruiken. De bestandsnaam zou de naam van de module zijn. Modules hebben ook hun eigen bereik. Als u variabelen buiten het bereik van de module wilt gebruiken, moeten ze worden geëxporteerd. Variabelen die niet worden geëxporteerd, zijn privé en kunnen alleen binnen de module worden geopend.
Individuele eigenschappen kunnen als volgt worden geëxporteerd:
exportfunctie foo () console.log ("Hello World"); exporteer bar = 82; exporteer laat baz = [1,2,3];Als alternatief kunnen alle eigenschappen met één exportinstructie worden geëxporteerd:
function foo () console.log ("Hello World"); laat bar = 82; laat baz = [1,2,3]; export foo, bar, baz;Als u de variabelen van een module wilt gebruiken, importeert u deze in het bestand. U kunt als volgt uit de module specificeren wat u wilt importeren:
importeer foo, bar, baz van "foo";
U kunt ook uw import hernoemen:
importeer foo als Foo van "foo"; Foo ();
Of u kunt alle eigenschappen van de module importeren:
importeer * als myModule van "foo"; myModule.foo ();
Met functies kunnen we onze programma's onderverdelen in kleinere programma's die we eenvoudig kunnen beheren. Deze praktijk staat bekend als modularizing. Er zijn twee soorten functies: ongeldige functies en functies voor het retourneren van waarden. Een void-functie voert de instructies die erin staan uit. Een waarde-terugstellingsfunctie geeft ons een waarde terug.
Scope is het deel van het programma waar een variabele toegankelijk is. Variabelen die binnen een functie worden gedeclareerd, inclusief de parameters van de functie, zijn lokaal. Blokken hebben ook een bereik en lokale variabelen kunnen in de blokken worden gemaakt.
Variabelen die niet in een blok of module zijn ingesloten, zijn algemeen. Als u een globale variabele nodig heeft, is het acceptabel om een globale constante te hebben. Probeer anders uw code te beperken tot modules, omdat modules hun eigen bereik hebben. Maar nog beter, modules geven uw codestructuur en organisatie.
