Függvények
A függvények olyan értékek, amelyek argumentumértékek halmazából egyetlen értékre való leképezést jelölnek. A függvényeket bemeneti értékek (argumentumértékek) készlete hívja meg, és egyetlen kimeneti értéket (a visszatérési értéket) hoz létre.
Függvények írása
A függvények függvénykifejezéssel íródnak:
függvény-kifejezés:
(
parameter-listopt)
function-return-typeopt=>
function-body
függvénytörzs:
kifejezés
paraméterlista:
fix-parameter-list
fix-parameter-list ,
optional-parameter-list
optional-parameter-list
rögzített paraméterlista:
paraméter
paraméter ,
fix-parameter-list
paraméter:
parameter-name parameter-typeopt
paraméter-név:
azonosító
paramétertípus:
követelés
függvény-return-type:
követelés
állítás:
as
nullable-primiitve-type
optional-parameter-list:
optional-parameter
optional-parameter ,
optional-parameter-list
optional-parameter:
optional
paraméter
nullable-primitve-type
nullable
opt primitív típusú
Az alábbiakban egy olyan függvényt mutatunk be, amely pontosan két értéket x
igényel, és y
az operátor ezen értékekre való alkalmazásának +
eredményét hozza létre. Azok a paraméterek, amelyek a függvény paraméterlistájának részei, és a x + y
függvény törzse:x
y
(x, y) => x + y
A függvénykifejezés kiértékelésének eredménye egy függvényérték előállítása (nem a függvénytörzs kiértékelése). Ebben a dokumentumban konvencióként a függvényértékek (a függvénykifejezésekkel ellentétben) a paraméterlistával, de a függvény törzse helyett három ponttal (...
) jelennek meg. Ha például a fenti függvénykifejezés kiértékelése megtörtént, az a következő függvényértékként jelenik meg:
(x, y) => ...
A függvényértékekhez a következő operátorok vannak definiálva:
Operátor | Eredmény |
---|---|
x = y |
Equal |
x <> y |
Nem egyenlő |
A függvényértékek natív típusa egy egyéni függvénytípus (amely a belső típusból function
származik), amely felsorolja a paraméterneveket, és megadja az összes paramétertípust és a visszatérési típust any
. (Ugrás a Függvénytípusok a függvénytípusok részleteihez.)
Függvények meghívása
A függvény függvénytörzse a függvény értékének meghívásos kifejezéssel történő meghívásával lesz végrehajtva. A függvényérték meghívása azt jelenti, hogy a függvényérték függvénytörzse kiértékelésre kerül, és visszaad egy értéket, vagy hiba keletkezik.
invoke-expression:
primary-expression (
argument-listopt )
argumentumlista:
kifejezéslista
Minden alkalommal, amikor függvényértékeket hív meg, a rendszer argumentumlistaként adja meg az értékek egy készletét, amelyet a függvény argumentumainak neveznek.
Az argumentumlistával rögzített számú argumentumot adhat meg közvetlenül kifejezéslistaként. Az alábbi példa egy mező függvényértékkel rendelkező rekordját definiálja, majd meghívja a függvényt a rekord egy másik mezőjéből:
[
MyFunction = (x, y, z) => x + y + z,
Result1 = MyFunction(1, 2, 3) // 6
]
Függvények invokálásakor a következő tart:
A függvény függvénytörzsének kiértékelésére használt környezet tartalmaz egy olyan változót, amely megfelel az egyes paramétereknek, és ugyanazzal a névvel, mint a paraméter. Az egyes paraméterek értéke a meghívási kifejezés argumentumlistájából létrehozott értéknek felel meg a Paraméterekben meghatározottak szerint.
A függvényargumentumoknak megfelelő összes kifejezés kiértékelése a függvény törzsének kiértékelése előtt történik.
A kifejezéslistában vagy függvénytörzsben lévő kifejezések kiértékelésekor felmerülő hibák propagálása megtörténik.
Az argumentumlistából létrehozott argumentumok számának kompatibilisnek kell lennie a függvény paramétereivel, vagy hiba keletkezik okkóddal
"Expression.Error"
. A kompatibilitás meghatározásának folyamatát a paraméterek határozzák meg.
Paraméterek
A paraméterlistában kétféle paraméter szerepelhet:
A kötelező paraméter azt jelzi, hogy a függvény meghívásakor mindig meg kell adni a paraméternek megfelelő argumentumot. A szükséges paramétereket először meg kell adni a paraméterlistában. A következő példában szereplő függvény meghatározza a szükséges paramétereket
x
, ésy
:[ MyFunction = (x, y) => x + y, Result1 = MyFunction(1, 1), // 2 Result2 = MyFunction(2, 2) // 4 ]
Az opcionális paraméter azt jelzi, hogy a függvény meghívásakor a paraméternek megfelelő argumentum adható meg, de nem kötelező megadni. Ha egy választható paraméternek megfelelő argumentum nincs megadva a függvény meghívásakor, akkor a függvény ehelyett az értéket
null
használja. A választható paramétereknek a paraméterlistában szereplő kötelező paraméterek után kell megjelennie. Az alábbi példában szereplő függvény egy rögzített paramétertx
és egy opcionális paraméterty
határoz meg:[ MyFunction = (x, optional y) => if (y = null) x else x + y, Result1 = MyFunction(1), // 1 Result2 = MyFunction(1, null), // 1 Result3 = MyFunction(2, 2), // 4 ]
A függvények meghívásakor megadott argumentumok számának kompatibilisnek kell lennie a paraméterlistával. Egy függvény F
argumentumkészletének A
kompatibilitása az alábbiak szerint számítható ki:
Hagyja, hogy az N érték az argumentumlistából létrehozott argumentumok
A
számát adja meg. Példa:MyFunction() // N = 0 MyFunction(1) // N = 1 MyFunction(null) // N = 1 MyFunction(null, 2) // N = 2 MyFunction(1, 2, 3) // N = 3 MyFunction(1, 2, null) // N = 3 MyFunction(1, 2, {3, 4}) // N = 3
Hagyja, hogy a Kötelező érték a rögzített paraméterek
F
számát, opcionálisan pedig a választható paraméterekF
számát adja meg. Példa:() // Required = 0, Optional = 0 (x) // Required = 1, Optional = 0 (optional x) // Required = 0, Optional = 1 (x, optional y) // Required = 1, Optional = 1
Az argumentumok
A
kompatibilisek a függvényekkelF
, ha az alábbiak igazak:- (N >= Rögzített) és (N <= (Rögzített + Nem kötelező))
- Az argumentumtípusok kompatibilisek a megfelelő paramétertípusokkal
F
Ha a függvény deklarált visszatérési típussal rendelkezik, akkor a függvény
F
törzsének eredményértéke kompatibilis a visszatérési típussalF
, ha a következő igaz:- A függvény törzsének a függvényparaméterekhez megadott argumentumokkal való kiértékelésével kapott érték olyan típussal rendelkezik, amely kompatibilis a visszatérési típussal.
Ha a függvény törzse olyan értéket ad vissza, amely nem kompatibilis a függvény visszatérési típusával, hiba keletkezik az okkóddal
"Expression.Error"
.
Rekurzív függvények
A rekurzív függvényérték írásához a hatókörön belüli függvényre a hatókörben lévő hatókörkezelő operátort (@
) kell használni. A következő rekord például egy olyan mezőt tartalmaz, amely meghatározza a Factorial
függvényt, és egy másik mezőt, amely meghívja azt:
[
Factorial = (x) =>
if x = 0 then 1 else x * @Factorial(x - 1),
Result = Factorial(3) // 6
]
Hasonlóképpen, kölcsönösen rekurzív függvények írhatók mindaddig, amíg minden elérni kívánt függvénynek van neve. Az alábbi példában a Factorial
függvény egy része újrabontásra került egy második Factorial2
függvényre.
[
Factorial = (x) => if x = 0 then 1 else Factorial2(x),
Factorial2 = (x) => x * Factorial(x - 1),
Result = Factorial(3) // 6
]
Bezárások
A függvények egy másik függvényt is visszaadhatnak értékként. Ez a függvény az eredeti függvény egy vagy több paraméterétől függhet. A következő példában a mezőhöz MyFunction
társított függvény egy függvényt ad vissza, amely a megadott paramétert adja vissza:
[
MyFunction = (x) => () => x,
MyFunction1 = MyFunction(1),
MyFunction2 = MyFunction(2),
Result = MyFunction1() + MyFunction2() // 3
]
Minden alkalommal, amikor a függvényt meghívják, egy új függvényértéket ad vissza a rendszer, amely fenntartja a paraméter értékét, így a meghíváskor a paraméter értéke lesz visszaadva.
Függvények és környezetek
A paraméterek mellett a függvénykifejezés függvénytörzse hivatkozhat a környezetben a függvény inicializálásakor jelen lévő változókra. A mező MyFunction
által definiált függvény például a következő rekord A
mezőjéhez C
fér hozzá:
[
A =
[
MyFunction = () => C,
C = 1
],
B = A[MyFunction]() // 1
]
A meghíváskor MyFunction
hozzáfér a változó C
értékéhez, annak ellenére, hogy olyan környezetből (B
) hívja meg, amely nem tartalmaz változót C
.
Egyszerűsített deklarációk
Az egyes kifejezések szintaktikai rövidítések, amelyek egyetlen, elnevezett _
paramétert (aláhúzásjelet) használó, nem beírt függvények deklarálására szolgálnak.
minden-kifejezés:
each
minden-kifejezéstörzs
minden-kifejezés törzse:
függvénytörzs
Az egyszerűsített deklarációkat gyakran használják a magasabb rendű függvényhívások olvashatóságának javítására.
A következő deklarációpárok például szemantikailag egyenértékűek:
each _ + 1
(_) => _ + 1
each [A]
(_) => _[A]
Table.SelectRows( aTable, each [Weight] > 12 )
Table.SelectRows( aTable, (_) => _[Weight] > 12 )