Funktioner i Lua

Funktioner är huvudmekanismen för abstraktion av deklarationer och uttryck i Lua, de kan utföra specifika uppgif.webpter, som oftast kallas procedurer eller underrutiner på andra språk.
Funktionerna är oftast skrivna med parenteser och en lista med argument som gör att den kan utföra en specifik åtgärd, där det kan vara så att dessa funktioner inte behöver argument, men parenteserna måste anges, låt oss se ett exempel funktioner som vi använder som uttryck inuti Lua:

Som vi kan se kan vi använda funktioner på båda sätten som beskrivs, men det finns ett specialfall där funktionen har ett enda argument och det argumentet är ett sträng bokstavligt eller en konstruktör för en tabell eller matris, i detta fall är parenteserna valfria, låt oss 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}) typ {} typ ({})

Enligt exemplet kunde vi skriva funktionerna på båda sätten, dessa är lika giltiga.
Ett program i Lua Du kan använda funktioner som definieras både i C och i själva språket, till exempel alla standardfunktioner i biblioteket Lua är skrivna i C, som inte är relevant för utvecklare, eftersom åkallandet av båda inte har någon skillnad.
Genom att veta detta skiljer sig definitionen inte från andra språk, den konventionella syntaxen för en funktion styrs av funktionens namn, en lista med parametrar och funktionens kropp, som är en lista med deklarationer, låt oss se ett exempel på illustrera det som förklaras:

 funktionsoperation (var) lokal summa = 0 summa = var + 6 retursumma slut

Vi har redan vår funktion, men på det sättet är den inte särskilt användbar, eftersom den måste åberopas genom att skicka den parameter den behöver, för att vi kan lägga till en rad till i vår kod för att åberopa den:

 funktionsoperation (var) lokal summa = 0 summa = var + 6 retursumma slututskrift (operation (57))

Om vi ​​kör vårt exempel i vår terminal kan vi se hur vårt program tar emot parametern och enligt de operationer som definieras inom vår funktion returnerar det ett värde:

FÖRSTORA

Något som vi kan lyfta fram från funktionerna i Lua, är att parametrarna fungerar som lokala variabler, eftersom de initieras med de värden de tar emot i funktionsanropet. Förutom detta kan vi åberopa en funktion med ett annat antal argument definierade i funktionen, Lua anpassar sig till detta på ett sätt som det gör med flera uppdrag, ett ämne som vi täckte i den senaste handledningen, där de extra argumenten kasseras och de extra parametrarna får värdetypen noll, låt oss till exempel föreställa oss att vi har följande funktion:

 funktion multipel_funktion (a, b) returnera a eller b -änden

Låt oss se hur vi i följande koddel kallar funktionen med olika parametrar och på höger sida hur tilldelningen utförs:

 f (8) a = 8, b = noll f (8, 15) a = 8, b = 15 f (8, 15, 4) a = 8, b = 15 (Värdet 4 kasseras)

Även om detta beteende kan leda till programmeringsfel, är det också användbart, särskilt för standardargument.
En okonventionell men ganska användbar egenskap hos Lua, är möjligheten att återge flera resultat, även fördefinierade språkfunktioner kan göra detta. Ett exempel på detta är funktionen string.find, som letar efter ett förekomstmönster i en given sträng, returnerar denna funktion två index, den första är indexet där detta mönster börjar och det andra är där det slutar, låt oss se ett praktiskt exempel på användningen av denna funktion som vi kan gör perfekt i vår interaktiva konsol:

Funktionerna vi skriver in Lua de kan också återvända flera resultat, för detta behöver vi bara lista dem efter vår återkomst, låt oss se ett exempel där vi skapar en funktion för att hitta den största av en lista med element i en array och dess position i den:

 funktion maximivärde (a) lokalt minimum = 1 lokal m = a [minimum] för i, val i ipar (a) gör om val> m då minimum = i; m = valändändretur m, minsta slututskrift (maxvärde ({8,10,23,12,5}))

Som vi kan se är vår funktion ganska enkel och i vår retur returnerar den två värden, som i detta fall enligt vad vi skickar ska vi returnera 23 som det största talet och 3 som positionen, låt oss se:

FÖRSTORA

Förutom funktionaliteten för att returnera flera resultat, Lua du kan också få en variabelt antal argument, till exempel genom själva handledningarna har vi använt funktionen skriva ut med ett, två och upp till tre argument, det vill säga det kan ta emot ett variabelt antal argument, men som detta gör kan de funktioner som vi utvecklar i Lua, Låt oss titta på ett exempel på detta:

 funktion exempel_funktion (…) lokal s = 0 för i, v i ipairs {…} gör s = s + v slut returnerar s slututskrift (exempel_funktion (8, 19, 30, 14, 10))

Om vi ​​är observatörer i definitionen av vår funktion har vi tre poäng (…) inom parentes indikerar detta att vår funktion accepterar ett variabelt antal argument, och när funktionen kallas samlas alla skickade argument internt och bearbetas sedan med funktionen iparLåt oss se resultatet av vår funktion som ansvarar för att lägga till alla argument som skickas till den:

FÖRSTORA

Som vi ser denna egenskap hos Lua Det är ganska användbart eftersom det tillåter oss att definiera vår funktion utan att ha kunskap om hur många argument vi kommer att föra till den, vi kan till och med säga att den här funktionen är lite lik den som görs med förberedda uttalanden att hantera operationer med databas på språk som PHP eller Java.
Skickar in argument Lua det är positionellt, det vill säga när vi åberopar en funktion, motsvarar dessa argument parametrarna enligt deras positioner, det första argumentet motsvarar den första parametern och så vidare, även om det ibland inte skulle skada att ange argumenten vid namn.
Denna funktionalitet liknar variabla argument, men när vi definierar namnen på våra argument är hanteringen av dem mycket enklare, där vi bara kan använda den här funktionen genom att använda en tabell eller ett arrangemang, något som är mycket användbart om vår funktion använder några av dessa parametrar valfritt, låt oss se följande samtal till en funktion som tar emot en viss mängd parametrar för att bygga ett fönster:

 skapa_fönster {x = 0, y = 0, bredd = 0, höjd = 200, titel = 'Lua -fönster', bakgrund = "blå", kanter = sant}

På detta sätt funktionen skapa_fönster Du är fri att kontrollera dessa argument med namn om du vill, låt oss se hur vi tar emot dessa argument i vår funktion och vad vi kan göra med det:

 function create_window (optioner) - kontrollera obligatoriska alternativ om typ (options.title) ~ = "string" sedan fel ("ingen titel") elseif typ (options.width) ~ = "number" och sedan fel ("inget mått på bredd" ) elseif typ (options.height) ~ = "number" och sedan fel ("ingen höjdmätning") slut - vi tillämpar alternativen create_window (options.title, options.x eller 0, options.y eller 0, options .width, alternativ.höjd, alternativ.bakgrund eller "vit", alternativ.kanter) Avsluta

Som vi kan se är möjligheterna i våra program mycket större med denna funktionalitet, och även om detta exempel är illustrativt, tillåter det oss att se hur vi kan tillämpa de namngivna argumenten inom våra funktioner.
Så här avslutar vi denna handledning, där vi lärde oss att hantera funktioner i Luafrån den konventionella syntax som vi kan hitta på andra språk till språkets egenskaper, till exempel flera resultat, variabla argument och möjligheten att namnge de argument som vi skickar till våra funktioner. På detta sätt kan vi lägga till mycket mer kraft i våra program genom att inkludera dessa typer av funktioner och behålla enkelheten Lua vi är vana vid det.Gillade du och hjälpte denna handledning?Du kan belöna författaren genom att trycka på den här knappen för att ge honom en positiv poäng