Lua Academy · Oppitunti

Funktioiden määrittely ja kutsuminen

Tutustukaa funktioiden määrittelysyntaksiin, kutsutapoihin sekä paikallisiin ja globaaleihin funktioihin.

Oppitunti 1/412 vaihetta

Funktioiden määrittely ja kutsuminen on ilmainen Lua Academy-oppitunti CoddyKitissä. Tämä on oppitunti 1/4. Voit lukea tästä oppimispolusta kokonaan mitkä tahansa 3 oppituntia ilmaiseksi — sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä käytännön harjoittelun sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Oppitunti kuuluu Lua Academy-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Lua Academy-kurssilla on yhteensä 4 oppituntia.

Funktion syntaksi

Funktiot määritellään Luassa function-avainsanalla. Runko on lohko, jonka päättää end. Funktiot voivat olla globaaleja tai paikallisia. Funktiota kutsutaan lisäämällä sulkeisiin argumentit. Jos argumentit jätetään pois, puuttuvien parametrien arvoksi tulee nil.

function sayHello(name)
  print("Hello, " .. (name or "World") .. "!")
end

sayHello("Lua")   -- Hello, Lua!
sayHello()        -- Hello, World!

local function add(a, b)
  return a + b
end
print(add(3, 4))  -- 7

Paluuarvot

Funktiot palauttavat arvoja return-lauseella. Toisin kuin useimmissa kielissä, Lua-funktiot voivat palauttaa useita arvoja. Jos palautusta ei määritellä erikseen, funktio ei palauta mitään (nolla arvoa). Ylimääräiset paluuarvot hylätään, kun kutsu ei ole luettelon viimeinen lauseke.

local function minMax(t)
  local lo, hi = t[1], t[1]
  for i = 2, #t do
    if t[i] < lo then lo = t[i] end
    if t[i] > hi then hi = t[i] end
  end
  return lo, hi
end

local lo, hi = minMax({5,2,8,1,9})
print(lo, hi)  -- 1  9

Funktio arvona

Funktiot ovat Luassa ensimmäisen luokan arvoja. Voitte tallentaa ne muuttujiin, välittää niitä argumentteina muille funktioille ja palauttaa niitä. Tämä mahdollistaa callback-funktiot, korkeamman asteen funktiot ja funktionaalisen ohjelmoinnin rakenteet.

local ops = {
  add = function(a, b) return a + b end,
  sub = function(a, b) return a - b end,
  mul = function(a, b) return a * b end,
}

local function apply(op, a, b)
  return op(a, b)
end

print(apply(ops.add, 10, 3))  -- 13
print(apply(ops.mul, 4, 5))   -- 20

Paikalliset ja globaalit funktiot

Käyttäkää local function-määrettä moduulin yksityisiin apufunktioihin. Globaalit funktiot saastuttavat globaalin nimiavaruuden ja ovat käytettävissä kaikkialta, mikä voi aiheuttaa nimiristiriitoja. Useimmissa tapauksissa suosikaa paikallisia funktioita ja tuokaa moduulitaulukon kautta näkyviin vain tarvitsemanne funktiot.

-- Bad: pollutes global namespace
function helper() end

-- Good: module-local
local function helper()
  return "I am local"
end

-- Module export pattern
local M = {}
function M.publicFunc()
  return helper()  -- can call local
end
return M

Metodit kaksoispistesyntaksilla

Lua tarjoaa syntaktisen lyhenteen taulukoiden metodien määrittelyyn ja kutsumiseen. obj:method(arg) vastaa ilmaisua obj.method(obj, arg). Kaksoispistemuoto välittää taulukon implisiittisesti ensimmäisenä argumenttina, jonka nimi on tapana olla self.

local Dog = {}
Dog.__index = Dog

function Dog.new(name)
  return setmetatable({name=name}, Dog)
end

function Dog:speak()
  print(self.name .. " says: Woof!")
end

local d = Dog.new("Rex")
d:speak()   -- Rex says: Woof!

Valinnaisten parametrien rakenne

Luassa ei ole sisäänrakennettuja valinnaisia parametreja, mutta voitte jäljitellä niitä tarkistamalla nil-arvoja. Välittäkää useita valinnaisia parametreja käyttäville funktioille yksi asetustaulukko — se on selkeämpi kuin pitkä argumenttiluettelo.

local function createUser(name, opts)
  opts = opts or {}
  return {
    name = name,
    role = opts.role or "user",
    active = opts.active ~= false,
    score = opts.score or 0,
  }
end

local u = createUser("Alice", {role="admin", score=100})
print(u.name, u.role, u.score)

Häntäkutsut

Häntäkutsu on funktiokutsu häntäasemassa eli viimeisenä toimintona ennen paluuta. Lua käyttää häntäkutsujen optimointia: kelvollinen häntäkutsu ei kuluta ylimääräistä pinotilaa. Tämä mahdollistaa syvän rekursion ilman pinon ylivuotoa, kun rekursiivinen kutsu on häntäasemassa.

local function factorial(n, acc)
  acc = acc or 1
  if n <= 1 then return acc end
  return factorial(n - 1, n * acc)  -- tail call!
end

print(factorial(10))  -- 3628800
-- Can handle very large n without stack overflow

Välittömästi kutsutut funktiot

Voitte määritellä ja kutsua funktion välittömästi: (function() ... end)(). Tämä on hyödyllistä paikallisen näkyvyysalueen luomiseen, alustuskoodin suorittamiseen täsmälleen kerran tai tilapäisten muuttujien pitämiseen poissa ulommasta näkyvyysalueesta.

local result = (function()
  local temp = 100
  local adjusted = temp * 1.5
  return math.floor(adjusted)
end)()

print(result)   -- 150
-- temp and adjusted not visible here

Funktioiden tallentaminen taulukoihin

Funktioiden tallentaminen taulukoihin on idiomaattinen tapa suunnitella Lua-moduuleja. Taulukko toimii nimiavaruutena. Funktiot määritellään sijoittamalla ne taulukon kenttiin tai käyttämällä piste- tai kaksoispistesyntaksia taulukon nimen kanssa.

local math2 = {}

function math2.clamp(val, lo, hi)
  return math.max(lo, math.min(hi, val))
end

function math2.lerp(a, b, t)
  return a + (b - a) * t
end

print(math2.clamp(150, 0, 100))  -- 100
print(math2.lerp(0, 10, 0.5))   -- 5.0

Sulkeumat callback-funktioina

Korkeamman asteen funktiot hyväksyvät callback-funktioita. Luassa callback-funktiot ovat yksinkertaisesti funktioarvoja. Sulkeumat ovat erityisen hyödyllisiä callback-funktioina, koska ne tallentavat kutsukontekstin ilman, että korkeamman asteen funktion kautta tarvitsee välittää ylimääräisiä argumentteja.

local function forEach(t, fn)
  for i, v in ipairs(t) do
    fn(v, i)
  end
end

local sum = 0
forEach({10, 20, 30}, function(v)
  sum = sum + v
end)
print(sum)   -- 60

forEach({"a","b","c"}, function(v, i)
  print(i, v)
end)

Pikatarkistus

Mikä on lausekkeen local function f() return 1, 2, 3 end; local a, b = f() tulos?

Vastaa interaktiivisessa oppitunnissa

Kertaus: Funktiot

Tärkeimmät kohdat:

Käyttäkää local function -määrettä globaalin nimiavaruuden sotkemisen välttämiseksi
Funktiot ovat ensimmäisen luokan arvoja: tallentakaa niitä muuttujiin ja taulukoihin sekä välittäkää niitä argumentteina
Kaksoispisteen syntaksi välittää implisiittisesti self-parametrin
Simuloikaa valinnaiset parametrit käyttämällä opts or {}
Häntä kutsut estävät pinon ylivuodon syvässä rekursiossa
Välittömästi kutsutut funktiot luovat eristettyjä näkyvyysalueita

Aloita maksutta

Opi Lua tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 40
Oppitunnit: 159

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Funktioiden määrittely ja kutsuminen” ilmainen?

Kyllä — voit lukea täällä verkossa kokonaan ilmaiseksi mitkä tahansa Lua Academy-oppimispolun 3 oppituntia, myös oppitunnin “Funktioiden määrittely ja kutsuminen”. Sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä interaktiiviset harjoitukset sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Lua Academy-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”Funktioiden määrittely ja kutsuminen”?

Tutustukaa funktioiden määrittelysyntaksiin, kutsutapoihin sekä paikallisiin ja globaaleihin funktioihin. Harjoittelet Lua Academy-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Lua Academy-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Lua Academy-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 1/4.

Kuinka kauan ”Funktioiden määrittely ja kutsuminen”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Lua Academy-oppitunnilla?

Kyllä. Jokainen Lua Academy-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

Funktioiden määrittely ja kutsuminen
Useat paluuarvot
Varargs ja ...-operaattori
Rekursio Luassa

← Takaisin: Lua Academy