Oppdrag og kontrollstrukturer i Lua

I tidligere opplæringsprogrammer så vi hvordan Lua tillater håndtering av både verdier og typer på en dynamisk måte, og skiller seg alltid ut for sin enkelhet og allsidighet når du utfører disse operasjonene.
Men dette er ikke alt Lua tilbyr når det gjelder enkelhet, støtter det konvensjonelt deklarasjoner som vi kan finne på språk som på C eller PascalHvor disse erklæringene inkluderer både oppdrag og kontrollstrukturer, kan vi til og med snuble over noen ukonvensjonelle måter som flere oppdrag og lokale erklæringer.
Oppgavene i Lua De er ekstremt enkle, og de jobber med å endre verdien av en variabel på et bestemt tidspunkt i programmet vårt, la oss se et enkelt eksempel ved å bruke den interaktive konsollen til Lua, som vi kan angi ved å plassere det reserverte ordet lua I terminalen:

Som vi kan se har vi noen enkle eksempler på oppgaver, som endrer verdien av variabler med sammenkoplingsoperasjoner, aritmetikk eller bare ved å skrive verdier. I tillegg til dette, Lua tillater flere tildelinger, der en liste med verdier er tilordnet en liste over variabler, og alltid skiller disse listene med kommaer for riktig drift:

Som vi kunne se var1 fikk den numeriske verdien og var2 tekstverdien, denne i henhold til rekkefølgen oppdraget gjøres i. Hvis vi er observatører, ser vi hvordan vi også kan veksle verdiene til begge variablene, noe som kommer godt med når vi jobber med funksjoner.
Lua du kan til og med justere antall verdier for antall tilstedeværende variabler, for eksempel hvis verdilisten er mindre enn listen over variabler, får de ekstra variablene verditypen null Som standard som verdier, la oss se et eksempel på denne prosessen:

Som vi kan se, mottar de to første variablene sine tilsvarende verdier, og den siste av disse mottar automatisk null som vi forklarer. Det er viktig å nevne at flere oppgaver ikke alltid er raskere enn enkle oppgaver, men de lar oss hjelpe oss med å samle inn flere returer fra et funksjonsanrop for å nevne noen.
I tillegg til globale variabler, Lua Den støtter lokale variabler som, i motsetning til globale, har et begrenset omfang, som er avhengig av blokken de er deklarert i. La oss se hvordan vi deklarerer en lokal variabel:

Som vi ser erklæringen av disse variablene, gjør vi dem med det reserverte ordet lokalDisse variablene fungerer i blokken de er deklarert i. For eksempel kan vi si at en blokk kan være en kontrollstruktur eller en funksjon, la oss se følgende eksempel:

 x = 10 lokal i = 1 mens i <= x gjør lokal x = i * 2 skrive ut (x) i = i + 1 ende hvis i> 20 så lokal xx = 20 utskrift (x + 2) annet skrive ut (x) ende skrive ut (x) 

Hvis vi utfører det samme i terminalen vår, vil vi se hvordan resultatet kanskje ikke er det vi forventer, og dette er fordi vi har forskjellige blokker der vi bruker variablene, la oss se resultatet:

Selv om kontrollen over programmet vårt kan være begrenset, kan vi bruke skilletegnene avslutning For å spesifisere en blokk og vite hvor langt våre lokale variabler har omfang, la oss se et eksempel der vi kan gjøre dette:

 gjør lokal var1 = 16 lokal var2 = var1 + 20 x = 5 y = x + var1 ende - Her ender omfanget av var1 og var2 utskrift (x, y) utskrift (var1, var2)

Når vi utfører det i terminalen vår, vil vi se at variablene x og y vises uten problemer fordi de er globale, men for var1 og var2 slutter omfanget med blokken avslutning, la oss se:

Vi kan understreke at bruk av lokale variabler i programmene våre er en god praksis, de hjelper oss med å ikke berøre det globale miljøet med unødvendige navn, også at tilgangen til disse variablene er mye raskere enn hvis vi gjorde det med globale variabler og til slutt disse variabler forsvinner så snart omfanget ender, og frigjør dermed minneplass, så vi anbefaler bruk av dem når det er mulig.
KontrollstrukturerSom resten av programmeringsspråk, Lua gir oss et sett med kontrollstrukturer som vi kan bruke i programmene våre, ved hjelp av det velkjente hvis å håndtere forhold og samtidig som, gjenta Y til for iterative sløyfer, der unntatt gjenta som har den eksplisitte terminatoren før og de andre slutter med slutt.
Som i de fleste programmeringsspråk erklæringen hvis sjekker en tilstand og utfører delen av deretter eller delen av ellers, hvor sistnevnte kan være valgfri, la oss se et sett med disse betingelsene som sett i programmene våre:

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

Her har vi tre typer operasjoner, den grunnleggende med deretter, ved å bruke retur for å returnere en verdi i henhold til tilstanden og et litt mer komplett stykke kode som kaller en funksjon. I tillegg til dette kan vi skrive hvis nestet ved hjelp av eller hvis, som sparer oss for å måtte bruke flere ender, la oss se hvordan det ser ut:

 hvis operasjon == " +" så resultat = a + b elseif operasjon == " -" så resultat = a - b elseif operasjon == " *" så resultat = a * b elseif operasjon == "/" så resultat = a / b else feil ("Ugyldig drift") slutt

Det er viktig å merke seg at dette ikke bare er mer optimalt, men også nødvendig siden Lua har ikke typedeklarasjonene bytte om så denne typen nestede forhold vil være ganske vanlig i programmene våre.
Som på andre språk, Lua først vurdere tilstanden til samtidig som, hvis betingelsen er falsk, ender sløyfen og ellers blir de følgende kodelinjene utført og prosessen gjentas til tilstanden er falsk, la oss se et enkelt eksempel for å illustrere dette:

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

Denne uttalelsen i motsetning til samtidig som lar oss gjenta koden inne i tilstanden til den er sann, der selv denne koden kan utføres minst én gang siden evalueringen av tilstanden er gjort på slutten, la oss se et eksempel:

 repeter linje = os.read () til linje ~ = "" print (linje)

Når det gjelder iterative sykluser til, Lua har to varianter av den, den for numerisk og generisk for. La oss se på syntaksen til det numeriske for:

 for var = exp1, exp2, exp3 gjør slutt

Denne sløyfen vil utføre noe for hver verdi av var fra eksp1 før eksp2 ved hjelp av exp3 som verdien for å øke var eller redusere den, hvis vi ikke inkluderer den Lua antar som standard at det går en etter en, la oss se et mer detaljert eksempel på disse syklusene:

 for var = 1, f (x) skriv ut (var) ende for var2 = 10,1, -1 gjør utskrift (var2) ende

Siden vi ser at applikasjonen er ganske enkel og lar oss implementere nyttige iterative sykluser i programmene våre, la oss nå se syntaksen for generisk for:

 for i, var i ipairs (array) skriver ut (var) end

Det denne syklusen gjør er å bruke funksjonen den gir oss Lua anrop ipairs, som er en iterator av matriser, hvor jeg for hver iterasjon tar en indeks, mens var oppnår verdien knyttet til indeksen.
Som vi ser utsagnene inne Lua De skiller seg ikke mye fra andre språk, men språket legger til den ekstra enkelheten for å gi oss en mye raskere læring av syntaksen og en mye mer effektiv bruk. Med dette fullfører vi denne opplæringen, der vi lærte oppgavene og kontrollstrukturene i Lua, og legger dermed til et nytt lag med kunnskap når det gjelder dette enkle, men kraftfulle språket.