Opgaver og kontrolstrukturer i Lua

I tidligere tutorials så vi hvordan Lua tillader håndtering af både værdier og typer på en dynamisk måde, altid skiller sig ud for sin enkelhed og alsidighed, når du udfører disse operationer.
Men det er ikke alt Lua tilbyder i form af enkelhed, det understøtter konventionelt erklæringer, som vi kan finde på sprog som i C eller PascalHvor disse erklæringer omfatter både opgaver og kontrolstrukturer, kan vi endda snuble over nogle ukonventionelle måder som flere opgaver og lokale erklæringer.
Opgaverne i Lua De er ekstremt enkle, og de arbejder på at ændre værdien af ​​en variabel på et bestemt tidspunkt i vores program, lad os se et enkelt eksempel ved hjælp af den interaktive konsol af Lua, som vi kan indtaste ved at placere det reserverede ord lua I terminalen:

Som vi kan se, har vi nogle enkle eksempler på tildelinger, der ændrer værdien af ​​variabler med sammenkædningsoperationer, aritmetik eller blot ved at skrive værdier. Udover dette, Lua tillader flere tildelinger, hvor en liste med værdier er tildelt en liste med variabler, og altid adskiller disse lister med kommaer for korrekt drift:

Som vi kunne se var1 fik den numeriske værdi og var2 tekstværdien, denne i henhold til den rækkefølge, som tildelingen foretages i. Hvis vi er observatører, ser vi, hvordan vi også kan skifte værdierne for begge variabler, noget der er praktisk, når vi arbejder med funktioner.
Lua du kan endda justere antallet af værdier for antallet af tilstedeværende variabler, for eksempel hvis værdilisten er mindre end listen over variabler, får de ekstra variabler værditypen nul som standard som værdier, lad os se et eksempel på denne proces:

Som vi kan se, modtager de to første variabler deres tilsvarende værdier, og den sidste af disse modtager automatisk nul som vi forklarer. Det er vigtigt at nævne, at flere tildelinger ikke altid er hurtigere end simple opgaver, men de giver os mulighed for at hjælpe os med at indsamle flere returneringer fra et funktionsopkald for at nævne nogle få.
Ud over globale variabler, Lua Det understøtter lokale variabler, der i modsætning til globale har et begrænset omfang, som er afhængigt af blokken, hvor de er blevet erklæret, lad os se, hvordan vi erklærer en lokal variabel:

Som vi ser erklæringen af ​​disse variabler, gør vi dem med det reserverede ord lokalDisse variabler fungerer i blokken, hvor de er blevet erklæret, for eksempel kan vi sige, at en blok kan være en kontrolstruktur eller en funktion, lad os se følgende eksempel:

 x = 10 lokal i = 1 mens i <= x gør lokal x = i * 2 udskriv (x) i = i + 1 ende hvis i> 20 så lokal xx = 20 udskrivning (x + 2) ellers udskriv (x) ende print (x) 

Hvis vi udfører det samme i vores terminal, vil vi se, hvordan resultatet muligvis ikke er, hvad vi forventer, og det er fordi vi har forskellige blokke, hvor vi bruger variablerne, lad os se resultatet:

Selvom kontrollen med vores program kan være begrænset, kan vi bruge afgrænserne slut For at angive en blok og vide, hvor langt vores lokale variabler har omfang, lad os se et eksempel, hvor vi kan gøre dette:

 gør lokal var1 = 16 lokal var2 = var1 + 20 x = 5 y = x + var1 ende - Her slutter omfanget af var1 og var2 print (x, y) print (var1, var2)

Når vi udfører det i vores terminal, vil vi se, at variablerne x og y vises uden problemer, fordi de er globale, men for var1 og var2 slutter deres omfang med blokken slut, Lad os se:

Vi kan understrege, at brugen af ​​lokale variabler i vores programmer er en god praksis, de hjælper os med ikke at røre det globale miljø med unødvendige navne, også at adgangen til disse variabler er meget hurtigere, end hvis vi gjorde det med globale variabler og endelig disse variabler forsvinder, så snart deres omfang ender og frigør hukommelsesplads, så vi anbefaler deres brug, når det er muligt.
KontrolstrukturerLigesom resten af ​​programmeringssprog, Lua giver os et sæt kontrolstrukturer, som vi kan bruge i vores programmer ved hjælp af de velkendte hvis at håndtere forhold og mens, gentage Y til for iterative sløjfer, hvor undtagen gentage som har den eksplicitte terminator så længe og de andre slutter med ende.
Som i de fleste programmeringssprog erklæringen hvis kontrollerer en tilstand og udfører den del af derefter eller den del af andet, hvor sidstnævnte kan være valgfri, lad os se et sæt af disse betingelser som set i vores programmer:

 hvis var1 <0 så var1 = 0 ende hvis var1 max linjer så viser () linjer = 0 ende

Her har vi tre typer operationer, den grundlæggende med derefter, ved hjælp af retur for at returnere en værdi i henhold til betingelsen og et lidt mere komplet stykke kode, der kalder en funktion. Udover dette kan vi skrive hvis indlejret ved hjælp af ellers, hvilket sparer os for at skulle bruge flere ender, lad os se, hvordan det ser ud:

 hvis operation == " +" så resultat = a + b elseif operation == " -" derefter resultat = a - b elseif operation == " *" derefter resultat = a * b elseif operation == "/" derefter resultat = a / b else fejl ("Ugyldig drift") slut

Det er vigtigt at bemærke, at dette ikke kun er mere optimalt, men også nødvendigt siden Lua ikke har typedeklarationer kontakt så denne type indlejrede forhold vil være ret almindelig i vores programmer.
Som på andre sprog, Lua først vurdere tilstanden af mens, hvis betingelsen er falsk, slutter sløjfen, og ellers udføres følgende kodelinjer, og processen gentages, indtil betingelsen er falsk, lad os se et enkelt eksempel for at illustrere dette:

 lokal i = 1 mens var1 [i] udskriver (var1 [i]) i = i + 1 ende

Denne erklæring i modsætning til mens giver os mulighed for at gentage koden inde i betingelsen, indtil den er sand, hvor selv denne kode kan udføres mindst én gang, siden evalueringen af ​​tilstanden er udført i slutningen, lad os se et eksempel:

 gentag linje = os.read () indtil linje ~ = "" print (linje)

Med hensyn til iterative cyklusser til, Lua har to varianter af den, den for numerisk og generisk for. Lad os se på syntaksen i det numeriske for:

 for var = exp1, exp2, exp3 slutter

Denne sløjfe vil udføre noget for hver værdi af var fra eksp1 så længe eksp2 ved brug af eksp3 som værdien for at øge var eller reducere den, hvis vi ikke inkluderer den Lua antager som standard, at det går en efter en, lad os se et mere detaljeret eksempel på disse cyklusser:

 for var = 1, f (x) udskriv (var) ende for var2 = 10,1, -1 udskriv (var2) ende

Da vi ser, at applikationen er ganske enkel og giver os mulighed for at implementere de nyttige iterative cyklusser i vores programmer, lad os nu se syntaksen for generisk for:

 for i, var i ipairs (array) print (var) end

Hvad denne cyklus gør, er at bruge den funktion, den giver os Lua opkald ipairs, som er en iterator af arrays, hvor jeg for hver iteration tager et indeks, mens var opnår den værdi, der er knyttet til dette indeks.
Som vi ser udsagnene indenfor Lua De adskiller sig ikke meget fra andre sprog, men sproget tilføjer den ekstra enkelhed til at give os en meget hurtigere læring af dens syntaks og en meget mere effektiv brug. Med dette afslutter vi denne vejledning, hvor vi lærte opgaverne og kontrolstrukturer inden for Lua, og tilføjer dermed endnu et lag af viden, når det kommer til dette enkle, men kraftfulde sprog.