Funkciók

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-list_opt)function-return-type_opt=>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-type_opt
paraméter-név:
      Azonosító
paramétertípus:
      követelés
függvény-return-type:
      követelés
Állítás:
      asnullable-primiitve-type
optional-parameter-list:
      optional-parameter
      optional-parameter,optional-parameter-list
optional-parameter:
      optionalParaméter
nullable-primitve-type
      nullable_optprimitív típusú

Az alábbiakban egy olyan függvényt mutatunk be, amely pontosan két értéket x igényel, és yaz 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 + yfüggvény törzse:xy

(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	Egyenlő
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 functionszá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-list_opt)
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.

Parameters

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 , és y:

    [ 
        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étert x és egy opcionális paramétert yhatá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éldául:

    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éterek Fszámát adja meg. Például:

  ()               // 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ényekkel F , 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ípussal F, 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örzsehivatkozhat 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 Amező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:
      eachminden-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 )