Funktioner i Lua

Funktioner er hovedmekanismen for abstraktion af erklæringer og udtryk i Lua, de kan udføre specifikke opgaver, som for det meste kaldes procedurer eller underprogrammer på andre sprog.
Funktionerne er oftest skrevet med parenteser og en liste over argumenter, der gør det muligt at udføre en bestemt handling, hvor det kan være tilfældet, at disse funktioner ikke har brug for argumenter, men parenteserne skal angives, lad os se et eksempel af funktioner, som vi bruger som udtryk indeni Lua:

Som vi kan se, kunne vi bruge funktioner på begge måder beskrevet, men der er et særligt tilfælde, hvor funktionen har et enkelt argument, og det argument er et streng bogstaveligt eller en konstruktør til et bord eller array, i dette tilfælde er parenteserne valgfri, lad os se:

 print "Hello World" print ("Hello World") dofile 'file.lua' dofile ('file.lua') print [[multi-line array msg]] print ([[multi-line array msg]]) f { var1 = 17, var2 = 30} f ({var1 = 17, var2 = 30}) type {} type ({})

Ifølge eksemplet kunne vi skrive funktionerne på begge måder, idet disse var lige gyldige.
Et program i Lua Du kan bruge funktioner, der er defineret både i C og i selve sproget, f.eks. Alle standardfunktionerne i biblioteket Lua er skrevet i C, som ikke er relevant for udviklere, da påkaldelsen af ​​begge ikke har nogen forskel.
Når man kender dette, adskiller definitionen sig ikke fra andre sprog, den konventionelle syntaks for en funktion styres af funktionens navn, en liste over parametre og funktionsdelen, som er en liste over deklarationer, lad os se et eksempel på illustrer det forklarede:

 funktionsoperation (var) lokal sum = 0 sum = var + 6 retur sum ende

Vi har allerede vores funktion, men på den måde er den ikke særlig nyttig, da den skal påberåbes ved at sende den parameter, den har brug for, for at vi kan tilføje endnu en linje til vores kode for at påberåbe den:

 funktionsoperation (var) lokal sum = 0 sum = var + 6 retur sum slut print (operation (57))

Hvis vi kører vores eksempel i vores terminal, kan vi se, hvordan vores program modtager parameteren, og i henhold til de operationer, der er defineret inden for vores funktion, returnerer det en værdi:

FORSTØRRE

Noget som vi kan fremhæve fra funktionerne i Lua, er, at parametrene fungerer som lokale variabler, da de initialiseres med de værdier, de modtager i funktionsopkaldet. Udover dette kan vi påkalde en funktion med et andet antal argumenter defineret i funktionen, Lua tilpasser sig dette på en måde, som det gør med flere tildelinger, et emne, som vi dækkede i den sidste vejledning, hvor de ekstra argumenter kasseres og de ekstra parametre får værditypen nulLad os f.eks. forestille os, at vi har følgende funktion:

 funktion multiple_function (a, b) returnerer a eller b ende

Lad os se, hvordan vi i den følgende kodedel kalder funktionen med forskellige parametre og på højre side, hvordan tildelingen udføres:

 f (8) a = 8, b = nul f (8, 15) a = 8, b = 15 f (8, 15, 4) a = 8, b = 15 (Værdien 4 kasseres)

Selvom denne adfærd kan føre til programmeringsfejl, er den også nyttig, især for standardargumenter.
En utraditionel, men ganske nyttig funktion af Lua, er evnen til at returnere flere resultater, selv foruddefinerede sprogfunktioner kan gøre dette. Et eksempel på dette er funktionen string.find, der leder efter et forekomstmønster i en given streng, returnerer denne funktion to indekser, den første er indekset, hvor dette mønster starter, og det andet er, hvor det ender, lad os se et praktisk eksempel på brugen af ​​denne funktion, som vi kan gør det perfekt i vores interaktive konsol:

De funktioner, vi skriver i Lua de kan også vende tilbage flere resultater, til dette skal vi kun liste dem efter vores hjemkomst, lad os se et eksempel, hvor vi opretter en funktion til at lokalisere den største af en liste over elementer i en matrix og dens position i den:

 funktion maksimal værdi (a) lokal minimum = 1 lokal m = a [minimum] for i, val i ipairs (a) gør hvis val> m derefter minimum = i; m = val end end return m, minimum end print (maksimal værdi ({8,10,23,12,5}))

Som vi kan se, er vores funktion ganske enkel, og i vores retur returnerer den to værdier, som i dette tilfælde i henhold til det, vi sender, skal returnere 23 som det største tal og 3 som positionen, lad os se:

FORSTØRRE

Ud over funktionaliteten til at returnere flere resultater, Lua du kan også modtage en variabelt antal argumenter, for eksempel i hele tutorials har vi brugt funktionen Print med et, to og op til tre argumenter, det vil sige, at det kan modtage et variabelt antal argumenter, men som dette gør, kan de funktioner, vi udvikler i Lua, Lad os se på et eksempel på dette:

 funktion eksempel_funktion (…) lokal s = 0 for i, v i ipairs {…} gør s = s + v slut returnerer s udskrift (eksempel_funktion (8, 19, 30, 14, 10))

Hvis vi er observatører i definitionen af ​​vores funktion, vi har tre punkter (…) inde i parentesen angiver dette, at vores funktion accepterer et variabelt antal argumenter, og når funktionen kaldes, indsamles alle de sendte argumenter internt og behandles derefter med funktionen ipairsLad os se output af vores funktion, der er ansvarlig for at tilføje alle de argumenter, der sendes til den:

FORSTØRRE

Som vi ser denne egenskab ved Lua Det er ganske nyttigt, da det giver os mulighed for at definere vores funktion uden at have kendskab til, hvor mange argumenter vi kommer til at videregive til den, vi kan endda sige, at denne funktionalitet ligner lidt det, der gøres med udarbejdede udsagn at håndtere operationer med Database på sprog som PHP eller Java.
Sender argumenter ind Lua det er positionelt, det vil sige, når vi påkalder en funktion, svarer disse argumenter til parametrene i henhold til deres positioner, det første argument svarer til den første parameter og så videre, selvom det nogle gange ikke ville skade at angive argumenterne ved navn.
Denne funktionalitet ligner variable argumenter, men når vi definerer navnene på vores argumenter, er håndteringen af ​​dem meget enklere, hvor vi ved hjælp af en tabel eller et arrangement kan gøre denne funktionalitet, noget der er meget nyttigt, hvis vores funktion bruger nogle af disse parametre valgfrit, lad os se følgende opkald til en funktion, der modtager en vis mængde parametre for at bygge et vindue:

 create_window {x = 0, y = 0, bredde = 0, højde = 200, titel = 'Lua -vindue', baggrund = "blå", kanter = sand}

På denne måde funktionen create_window Du er fri til at kontrollere disse argumenter ved navn, hvis du ønsker det, lad os se, hvordan vi modtager disse argumenter i vores funktion, og hvad vi kan gøre med det:

 funktion create_window (optioner) - tjek obligatoriske muligheder, hvis type (options.title) ~ = "string" derefter fejl ("ingen titel") elseif type (options.width) ~ = "number" derefter fejl ("intet mål for bredde" ) elseif type (optioner.højde) ~ = "tal" derefter fejl ("ingen højdemåling") slut - vi anvender indstillingerne create_window (options.title, options.x eller 0, options.y eller 0, options .width, optioner.højde, options.baggrund eller "hvid", options.edges) Slut

Som vi kan se, er mulighederne i vores programmer meget større med denne funktionalitet, og selvom dette eksempel er illustrerende, giver det os mulighed for at se, hvordan vi kan anvende de navngivne argumenter inden for vores funktioner.
Sådan afslutter vi denne vejledning, hvor vi lærte at håndtere funktioner i Luagår fra den konventionelle syntaks, som vi kan finde på andre sprog, til sprogets karakteristika, såsom flere resultater, variable argumenter og muligheden for at navngive de argumenter, vi sender til vores funktioner. På denne måde tilføjer vi meget mere strøm til vores programmer ved at inkludere disse typer funktioner og opretholde den enkelhed Lua vi er vant til det.Kan du lide og hjælpe denne vejledning?Du kan belønne forfatteren ved at trykke på denne knap for at give ham et positivt punkt